Arduino.ru

Никто с камерой не работал, да?

Поддерживаю твой вопрос, т.к. сам интересуюсь подобным вопросом.

Нечто подобное было тут: 

1. http://habrahabr.ru/post/119324/

2. http://learn.adafruit.com/ttl-serial-camera/

PolzovatelPC, к сожалению ttl-serial-camera - это замечательная камера, которая аппаратно сжимает кадр в jpeg и отдает его по UART, т.е. такую камеру подключить легко, но цена 3 раза выше.

Сам искал, что можно сделать с OV7670. Нашел сайт с примером реализации, где автор снимает Марио и ардуино, с помощью данного модуля, распознает картинку, но автор не прилагает ни схем, ни кода, почему его ресурс оказывается бесполезен. Решил, что потом разберусь и заказал камеру.

Немного покапавшись по просторам нарыл:

1. http://qrfnfgre.wordpress.com/2012/05/07/ov7670-camera-sensor-success/

2. http://qrfnfgre.wordpress.com/2012/10/20/ov7670-fifo-msp430-launchpad/

В кратце. Данная камера легко УПРАВЛЯЕТСЯ ардуиной, т.е. по SPI можно инициализировать камеру и она будет гнать кадры, куда-нибудь, например на LCD экран, подо что есть специальный шилд и примеры кода. Данный шилд умеет уже и писать на SD. Сама камера работает на частоте 24МГц, что для 8-ми разрядной AVR-ки не подсилу. Один кадр занимает аж 64Кб, на что у AVR также не хватит памяти. Однако можно кадр сперва засунуть в FIFO память, например в AL422, а затем от туда потихоньку отправить в любом направлении. По работе с SD примеры в сети есть.

К сожалению, самому с этим заморачиваться пока некогда. Может найдется кто грамотный, кто найдет доступный аналог AL422 (что-то AL422 в продаже не гуляет в России особо) и сможет доступно описать пример? Интересно повторить что-то вроде ov7670-fifo-msp430-launchpad, только с arduino, не поднимая сильно в цене данную связку, иначе выгоднее ttl-serial-camera.

Нарыл вот такую хохоряшку, сразу с фифо

http://www.emartee.com/product/42043/OV7670%20AL422%20FIFO%20Camera%20Mo...

может кто-то нашел схему подключения OV7670 к Arduino ?

что-то тут

http://embeddedprogrammer.blogspot.ru/2012/07/hacking-ov7670-camera-module-sccb-cheat.html

я тоже озабочен поиском камеры к Ардуино, но максимальным разрешением и размером матрицы

с управлением-снимок, на экран, на карточку(jpg,raw), с карточки на экран. Эдакий аналог фотоаппарата.

Из инета по максимуму 5MP OV5642 Camera Module

active array size: 2592 x 1944

output formats :
(8-bit): YUV(422/420) / YCbCr422,
RGB565/555/444, CCIR656,
8-bit compression data,
8/10-bit raw RGB data

shutter: rolling shutter

scan mode: progressive
pixel size: 1.4 µm x 1.4 µm
image area: 3673.6 µm x 2738.4 µm

немного не то, но буду искать

а по вашей задумке - посмотрите тут http://www.arducam.com/arducam-shield-rev-b-released-significant-improvement/

ага спасибо ранее видел, но не приглядывался. сейчас увидел архив с библиотекой

для включения и управляющий код для вывода на лсд и карту

надо переводить тест, не понятно они плату совместимую продают или это прослойка между мегой и туда втыкается камера? Ни цен на сайте ничего такого...

плата втыкается в мегу, а в плату камера

купить за $49.99 можно тут http://www.uctronics.com/arduino-camera-shield-arducam-lf-32-inch-tft-lcd-for-uno-mega2560-board-p-1444.html

есть вариант за $29.99, но я не разбирался в функциональных отличиях http://www.uctronics.com/arduino-camera-shield-arducam-for-uno-mega2560-board-p-1445.html

спасибо, надо наверное заказать будет...

сравнил визуально, у второго варианта нет LCD дисплейчика

по цене недорого, оплата пересыла это уже другой вопрос...в России врядли такое есть

Дешевле обзавестить stm32f4discovery. В России можно заказать на elitan.ru всего 600р. (не сочтите за рекламу, сам там покупал, ибо дешевле всего и быстрее получается).

В самой stm32f4discovery есть DMA, что позволяет МК сразу без всяких буферов гнать картинку куда надо (например, по USB, через виртуальный com-порт на комп) и памяти в целом хватает. Под нее и примеры есть, только не очень адекватные. У самого руки никак не дойдут подключить и попробовать.

Есть небольшая идея как подключить к arduino без буфера: запустить 8-ми биный режим на максимальное разрешение 640х480 при минимальном тактировании 10MHz. Arduino затактировать от 20MHz. Далее код на асме для копирования в память одной строки изображения, через пиксель (тут главное попасть на передачу байта, а не на переходные процессы, что можно корректировать при старте), получится разрешение ниже в 2 раза, т.е. 320 пикселей. Следующую строку не читаем, а вместо этого из памяти необходимо первую строчку куда-то передать, например по UART на скорости 11500 и т.д.. Можно пропускать больше строк, а брать пропущенные строки со следующего кадра, что добавит полосы если есть активное движение в кадре, зато картинку медленно, но получите. Такой подход реален, если правильно расчитать тактирование (похожий подход у проекта http://www.jrobot.net/Projects/AVRcam.html). Если AVR выдержит переходные процессы на такой скорости, то должно получится (сам пока только теоритические наброски сделал с расчетом длительности выполнения каждой команды, т.е. все в описанный алгоритм укладывается по тактам, но все некогда заняться основательно).

в том и дело, что попроще бы с программированием, а то время уходит. запись-чтение может проще, а вот менюшки и прочее требует детальной проработки. Сейчас продают сенсоры всборе с объективом с харастеристиками лучше чем OV****, пример Объектив Canon A2000/A2100 (в сборе, с матрицей), даже подороже (Zoom) Canon G12 (в сборе, с матрицей), и размер больше...а вот как подключить всё добро непонятно. Отрытые фотки с OV, что-то сейчас по качеству не удолетворяют...неудивительно такой крошечный сенсор...

По проще если брать камеру jpeg типа http://learn.adafruit.com/ttl-serial-camera/ (было выше).

По качеству, наверное проще взять за основу какой-нить TP-LINK с usb и веб камеру. Под linux все настраиваем и радуемся. http://robocraft.ru/blog/electronics/1053.html.

OV, хороши ценой и доступностью, но обвязка, для управление arduino`й получается слишком дорогой, туже FIFO память не найдешь у нас в розницу, либо цена зашкаливает. Также там огромное число настроек, поигравшись с которыми получают и вполне приличное качество изображения, но трудоемко.

Вобщем все зависит от цели: качество, скорость или цена. Все сразу можно получить только при большой партии конечного устройства (оптом дешевле и достать легче).

уныло, интересует качество, скорость устроит 1кадр сек, не менее 5 мегапикселей.

Одиночное изделье...

5 мегапикселей, через ардуину не получите - ресурсов не откуда столько взять.

Для Вас самый оптимальный вариант с TP-LINK, там поддерживаются камеры и 8 мегапикселей http://ideasonboard.org/uvc/

Только что смотрел, дешевле 753р (+5 дней ждать) нет, +500р по любому (если не брать на 10000р), даже если сам будешь забирать, а если почтой, то там 300р. Так что как ни крути, меньше 1000 не получится.

А на chipnn, там 740р, но там еще и доставка с Нижнего, те же 300р, хотя можно и за 175р пересылку заказать. Пожалуй самая демократичная цена.

Ах да, есть еще на мкпочтой, 1090р.

Увы, в этой стране купить что то за внятные деньги - нереально. Сам присматриваюсь к DISCOVERY

Действительно уже подорожало :(

Но я там обычно много всего сразу стараюсь заказывать и стоимость доставки уже значения мало имеет. По скорости где-то чуть больше недели получается. Вот из китая 2-3 месяца идет, на томожне весит большую часть времени (в статусе, естественно пусто и кажется, что потеряли).

А вот Техасцы за бесплатно фидексом отправляют - в 4 дня получается. Но их платы или слишком дорогие или слабоваты по ресурсам, хотя лаунчпад достойная замена ардуино. Кстати тоже есть примеры работы с OV, но опять только на инициализацию или через FIFO.

Кстати, еще вспомнил вариант - фарнелл, говорят в те же деньги выходит

Фарнел хорошая контора, шипинг до 10кг стоит 20 евро за любую покупку. Причем сам выбираешь UPS или EMS - цена одна. Если до 200 евро ups привозит за 4-5 дней

но вот по ценам на сами товары надо конкретику смотреть, может быть хорошая цена, а может не очень

кстати они офиц поставщик распбери - 27 евро версия B или 19 версия А

чем не вариант для обработки изображения? Ресурсов там более чем достаточно и для обработки и даже для хранения

вот интересная страничка, там есть готовый модуль 5мп камеры http://ru.farnell.com/jsp/bespoke/bespoke7.jsp?bespokepage=farnell/en_UK...

купил OV7670, как подключить к таким слабым процам как на ардуино uno r3,leonardo или nano. Если заменить кварц на более шустрый ?

С процов "как на ардуино uno r3,leonardo или nano" можно только управлять камерой по SPI: инициализировать, менять настроки отображения, режимы.

Чтобы получить именно изображения, нужны камешки потолще, см. выше данную тему.

Заменить кварц у Вас не получиться ибо просто не запустятся они у Вас, хотя есть случаи незначительного разгона. На самих данных платах, как правило уже установлен кварц максимальной для камня частоты, за редким исключением: установлен типовой кварц 16MHz, а камень, который штатно может работать на 20MHz. Но 20MHz также не достаточно, ибо за один такт камеры вы полчаете 1 байт, скажем на один порт, а МК надо считать данные из порта в регистр, записать данные из регистра в память проинкрементировать указатель памяти и прыгнуть на начало цикла чтения. Также желательно делать доп. обработки/проверки начала/конца передачи строки/кадра. Можете прикинуть во сколько раз шустрее должен быть МК, чем камера. 

И, на конец, у АВРок просто не хватит памяти, чтобы уместить даже самый маленький кадр.

Прошу прощения за некропостинг и не совсем по теме.

Мне нужно обрабатывать изображение именно на Ардуине и скорость важна (30fps), но я готов чуть-чуть пожертвовать качеством картинки .... 7x5 пикселей. :) Так сказать распознавание образов :)

Т.е. распознать усредненный цвет в блоке из 2200 пикселей (если камера, например, физически 320x240, а меня интересует разбиение всей зоны ее охвата на 35 блоков - даже сформулировать не могу :(, но ни в коем случает не прочитать 5 первых строк из 7 пикселей).

Какие могут быть решения? Подумывал о TCS230, но там не далее 10 мм от объекта и 35 модулей это еще та конструкция. Камер в виде модулей с разрешением 7x5 не встречал...

А вот если бы удалось "распознать образ" с камеры (что-то типа "(PAL) 1/3 Inch CMOS Camera Module PC1089 Sensor + 600TVL PAL Signal System"), заполнив матрицу 7x5 усредненными RGB'шными значениями (или есть более оптимальные представления цвета? - пока не разбирался).

Подскажите хотя бы идею.

О дальнейшей обработке пока не думал, т.к. скорее всего, не получится реализовать "распознавание". Но, что-то типа, формировать аналоговые сигналы на 7x5x3(R,G,B)=105 пинах.

Спасибо.

вот тут есть вариант http://roboforum.ru/forum88/topic6822.html

Смысл, что на вход подаете обычный видеосигнал и получаете картинку небольшого разрешения, даже остается сколько-то процессорного времени на доп. обработки, но там меньше чем 30 fps.

Вот здесь про эту камеру написано, правдв не знаю, на сколько рабочие решения, не успел прочитать:

http://forum.arduino.cc/index.php?/topic,174659.0.html

http://forum.arduino.cc/index.php/topic,139286.0.html

http://forum.arduino.cc/index.php?topic=159557.75

https://gist.github.com/freespace/2585921

Имею arduino uno
модуль камеры ov7670
Модуль microSD карты для arduino
Вопрос такой, 
Возможно ли реализовать, хватит ли мощности у ардуино на то,что камера делает снимок и сохраняет это на флеш карте?
Если да, то:
1. как правильно подключить модуль камеры?
2.Библиотека или пример кода работы с камерой

Если у вас камера с fifo-буфером (наличие на борту микросхемы AL422), то без проблем. Пошарьте по сссылкам выше, должен найтись примерчик подходящий или около того.

Без буфера уже из ряда фантастики. Максимум, что может получиться, при точном расчете тактовой частоты, это чтение по строке кадра с пропусками 1-2 пикселя, пропуская следующую 1 или 2 сроки, при этом записывать строку из памяти на карту, ждать следующу строку и т.д.. Т.е. из разрешения 640х480 Вы получите, скажем, 210х160. Но таких попыток вроде никто не делал... Вернее, открытых кодов нет.

В любом случае на лету получить jpeg точно не получиться, т.к. по любому не хватит памяти.

Наткнулся случайно на одну ссылку, где автор подключает ov7670 (без fifo) к arduino uno (atmega328p) и передает данные по uart на комп, где получает вполне качественную картинку.

https://github.com/ComputerNerd/ov7670-no-ram-arduino-uno - сам проект

https://github.com/ComputerNerd/simpleFrameGrabber - программа для просмотра на компе.

единственное, что все расчитано на linux. Мне удалось откомпилировать и записать прошивку и под windows, используя дистрибутив оболочки arduino (просто в Makefile везде указал полный путь до утитлит типа avr-gcc и запускал make из командной строки с полным путем к нему, а для загрузки пришлось немного там же подредактировать строчку с avrdude)

#########  AVR Project Makefile Template   #########
######                                        ######
######    Copyright (C) 2003-2005,Pat Deegan, ######
######            Psychogenic Inc             ######
######          All Rights Reserved           ######
######                                        ######
###### You are free to use this code as part  ######
###### of your own applications provided      ######
###### you keep this copyright notice intact  ######
###### and acknowledge its authorship with    ######
###### the words:                             ######
######                                        ######
###### "Contains software by Pat Deegan of    ######
###### Psychogenic Inc (www.psychogenic.com)" ######
######                                        ######
###### If you use it as part of a web site    ######
###### please include a link to our site,     ######
###### http://electrons.psychogenic.com  or   ######
###### http://www.psychogenic.com             ######
######                                        ######
####################################################


##### This Makefile will make compiling Atmel AVR 
##### micro controller projects simple with Linux 
##### or other Unix workstations and the AVR-GCC 
##### tools.
#####
##### It supports C, C++ and Assembly source files.
#####
##### Customize the values as indicated below and :
##### make
##### make disasm 
##### make stats 
##### make hex
##### make writeflash
##### make gdbinit
##### or make clean
#####
##### See the http://electrons.psychogenic.com/ 
##### website for detailed instructions


####################################################
#####                                          #####
#####              Configuration               #####
#####                                          #####
##### Customize the values in this section for #####
##### your project. MCU, PROJECTNAME and       #####
##### PRJSRC must be setup for all projects,   #####
##### the remaining variables are only         #####
##### relevant to those needing additional     #####
##### include dirs or libraries and those      #####
##### who wish to use the avrdude programmer   #####
#####                                          #####
##### See http://electrons.psychogenic.com/    #####
##### for further details.                     #####
#####                                          #####
####################################################


#####         Target Specific Details          #####
#####     Customize these for your project     #####

# Name of target controller 
# (e.g. 'at90s8515', see the available avr-gcc mmcu 
# options for possible values)
MCU=atmega328p

# id to use with programmer
# default: PROGRAMMER_MCU=$(MCU)
# In case the programer used, e.g avrdude, doesn't
# accept the same MCU name as avr-gcc (for example
# for ATmega8s, avr-gcc expects 'atmega8' and 
# avrdude requires 'm8')
PROGRAMMER_MCU=m328p

# Name of our project
# (use a single word, e.g. 'myproject')
PROJECTNAME=ov7670NoRam

# Source files
# List C/C++/Assembly source files:
# (list all files to compile, e.g. 'a.c b.cpp as.S'):
# Use .cc, .cpp or .C suffix for C++ files, use .S 
# (NOT .s !!!) for assembly source code files.
PRJSRC=main.c ov7670.c

# additional includes (e.g. -I/path/to/mydir)
INC=

# libraries to link in (e.g. -lmylib)
LIBS=

# Optimization level, 
# use s (size opt), 1, 2, 3 or 0 (off)
OPTLEVEL=2


#####      AVR Dude 'writeflash' options       #####
#####  If you are using the avrdude program
#####  (http://www.bsdhome.com/avrdude/) to write
#####  to the MCU, you can set the following config
#####  options and use 'make writeflash' to program
#####  the device.


# programmer id--check the avrdude for complete list
# of available opts.  These should include stk500,
# avr910, avrisp, bsd, pony and more.  Set this to
# one of the valid "-c PROGRAMMER-ID" values 
# described in the avrdude info page.
# 
AVRDUDE_PROGRAMMERID=arduino

# port--serial or parallel port to which your 
# hardware programmer is attached
#
AVRDUDE_PORT=COM10


####################################################
#####                Config Done               #####
#####                                          #####
##### You shouldn't need to edit anything      #####
##### below to use the makefile but may wish   #####
##### to override a few of the flags           #####
##### nonetheless                              #####
#####                                          #####
####################################################


##### Flags ####

# HEXFORMAT -- format for .hex file output
HEXFORMAT=ihex

# compiler
CFLAGS=-LD:\dtvims\arduino-1.0.5-r2\hardware\tools\avr\avr\lib\ldscripts  -I. $(INC) -g -mmcu=$(MCU) -O$(OPTLEVEL)  \
	-fpack-struct -fshort-enums             \
	-funsigned-bitfields -funsigned-char    \
	-Wall -Wstrict-prototypes               \
	-Wa,-ahlms=$(firstword                  \
	$(filter %.lst, $(<:.c=.lst)))

# c++ specific flags
CPPFLAGS=-fno-exceptions \
	-Wa,-ahlms=$(firstword         \
	$(filter %.lst, $(<:.cpp=.lst))\
	$(filter %.lst, $(<:.cc=.lst)) \
	$(filter %.lst, $(<:.C=.lst)))

# assembler
ASMFLAGS =-I. $(INC) -mmcu=$(MCU)        \
	-x assembler-with-cpp            \
	-Wa,-gstabs,-ahlms=$(firstword   \
		$(<:.S=.lst) $(<.s=.lst))


# linker
LDFLAGS=-LD:\dtvims\arduino-1.0.5-r2\hardware\tools\avr\avr\lib\ldscripts -Wl,-gc-sections,-Map,$(TRG).map -mmcu=$(MCU) -O$(OPTLEVEL) $(LIBS)

##### executables ####
CC=D:\dtvims\arduino-1.0.5-r2\hardware\tools\avr\bin\avr-gcc
OBJCOPY=D:\dtvims\arduino-1.0.5-r2\hardware\tools\avr\bin\avr-objcopy
OBJDUMP=D:\dtvims\arduino-1.0.5-r2\hardware\tools\avr\bin\avr-objdump
#SIZE=D:\dtvims\arduino-1.0.5-r2\hardware\tools\avr\avr\bin\size
AVRDUDE=D:\dtvims\arduino-1.0.5-r2\hardware\tools\avr\bin\avrdude
REMOVE=D:\dtvims\arduino-1.0.5-r2\hardware\tools\avr\utils\bin\rm -f

##### automatic target names ####
TRG=$(PROJECTNAME).out
DUMPTRG=$(PROJECTNAME).s

HEXROMTRG=$(PROJECTNAME).hex 
HEXTRG=$(HEXROMTRG) $(PROJECTNAME).ee.hex
GDBINITFILE=gdbinit-$(PROJECTNAME)

# Define all object files.

# Start by splitting source files by type
#  C++
CPPFILES=$(filter %.cpp, $(PRJSRC))
CCFILES=$(filter %.cc, $(PRJSRC))
BIGCFILES=$(filter %.C, $(PRJSRC))
#  C
CFILES=$(filter %.c, $(PRJSRC))
#  Assembly
ASMFILES=$(filter %.S, $(PRJSRC))


# List all object files we need to create
OBJDEPS=$(CFILES:.c=.o)    \
	$(CPPFILES:.cpp=.o)\
	$(BIGCFILES:.C=.o) \
	$(CCFILES:.cc=.o)  \
	$(ASMFILES:.S=.o)

# Define all lst files.
LST=$(filter %.lst, $(OBJDEPS:.o=.lst))

# All the possible generated assembly 
# files (.s files)
GENASMFILES=$(filter %.s, $(OBJDEPS:.o=.s)) 


.SUFFIXES : .c .cc .cpp .C .o .out .s .S \
	.hex .ee.hex .h .hh .hpp


.PHONY: writeflash clean stats gdbinit stats

# Make targets:
# all, disasm, stats, hex, writeflash/install, clean
all: $(TRG)

disasm: $(DUMPTRG) stats

stats: $(TRG)
	$(OBJDUMP) -h $(TRG)
#	$(SIZE) $(TRG) 

hex: $(HEXTRG)


writeflash: hex
	$(AVRDUDE) -c $(AVRDUDE_PROGRAMMERID)  -b 57600 \
	 -C D:\dtvims\arduino-1.0.5-r2\hardware\tools\avr\etc\avrdude.conf \
	 -v -p $(PROGRAMMER_MCU) -P $(AVRDUDE_PORT) -e        \
	 -U flash:w:$(HEXROMTRG)

install: writeflash

$(DUMPTRG): $(TRG) 
	$(OBJDUMP) -S  $< > $@


$(TRG): $(OBJDEPS) 
	$(CC) $(LDFLAGS) -o $(TRG) $(OBJDEPS)


#### Generating assembly ####
# asm from C
%.s: %.c
	$(CC) -S $(CFLAGS) $< -o $@

# asm from (hand coded) asm
%.s: %.S
	$(CC) -S $(ASMFLAGS) $< > $@


# asm from C++
.cpp.s .cc.s .C.s :
	$(CC) -S $(CFLAGS) $(CPPFLAGS) $< -o $@



#### Generating object files ####
# object from C
.c.o: 
	$(CC) $(CFLAGS) -c $< -o $@


# object from C++ (.cc, .cpp, .C files)
.cc.o .cpp.o .C.o :
	$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@

# object from asm
.S.o :
	$(CC) $(ASMFLAGS) -c $< -o $@


#### Generating hex files ####
# hex files from elf
#####  Generating a gdb initialisation file    #####
.out.hex:
	$(OBJCOPY) -j .text                    \
		-j .data                       \
		-O $(HEXFORMAT) $< $@

.out.ee.hex:
	$(OBJCOPY) -j .eeprom                  \
		--change-section-lma .eeprom=0 \
		-O $(HEXFORMAT) $< $@


#####  Generating a gdb initialisation file    #####
##### Use by launching simulavr and avr-gdb:   #####
#####   avr-gdb -x gdbinit-myproject           #####
gdbinit: $(GDBINITFILE)

$(GDBINITFILE): $(TRG)
	@echo "file $(TRG)" > $(GDBINITFILE)
	
	@echo "target remote localhost:1212" \
		                >> $(GDBINITFILE)
	
	@echo "load"        >> $(GDBINITFILE) 
	@echo "break main"  >> $(GDBINITFILE)
	@echo "continue"    >> $(GDBINITFILE)
	@echo
	@echo "Use 'avr-gdb -x $(GDBINITFILE)'"


#### Cleanup ####
clean:
	$(REMOVE) $(TRG) $(TRG).map $(DUMPTRG)
	$(REMOVE) $(OBJDEPS)
	$(REMOVE) $(LST) $(GDBINITFILE)
	$(REMOVE) $(GENASMFILES)
	$(REMOVE) $(HEXTRG)
	


#####                    EOF                   #####

А что в итоге? Смотрелку все-равно запускал в linux и даже получил картинку. Картинка грузится по кусочкам, но у меня эти кусочки не совпадают, то съезжают в сторону, то отваливается цветность. Однако, на кусочках видно вполне нормальную картинку (главное фокус отрегулировать), что говорит о том, что камера работает и что на arduino тоже можно получить картинку с данной камеры, а при некотором упорстве получить и неплохой сенсор.

Ввиду того, что автор буквально сегодня поменял исходники, а на новых исходниках, у меня вообще не было картинки, то на всякий случай выложил два архива у себя:

http://www.rukodelie-ds.ru/platy/ov7670-no-ram-arduino-uno-master_0.zip - старые

http://www.rukodelie-ds.ru/platy/ov7670-no-ram-arduino-uno-master_1.zip - новые

https://github.com/ComputerNerd/ov7670-no-ram-arduino-uno/issues/4#issuecomment-94321312 - тут может быть есть ответы на некоторые вопросы.

на DUE организовал получение картинки 320*240 (градации серого).

картинку делил так:

счетчиком фиксировал в буфере каждый четвертый байт с камеры, в 0-й бит буфера завел сигнал 4-й бит счетчика, соответственно 0-й бит с камеры отбросил. таким образом в 0-ом бите буфера с каждым новым байтом бит инвертировался. И так получилась картинка 320*480.

процедуру приема картинки написал на ASM-е данные принимал через строку (иначе не хватит памяти ардуины), данные считывал из буфера и если изменился 0-й бит, сохранял как новый пиксель.

Подготовил описание и проект для Arduino Uno и Winfows:

http://privateblog.info/arduino-uno-i-kamera-ov7670-primer-ispolzovaniya/