Raspistill lento para disparar?

Estou tentando acionar "muitas" framboesas juntas, enquanto o uso de raspistill é apenas para teste, estou me perguntando por que tirar uma foto é tão lenta, fiz um teste e, ao mesmo tempo em que apertei enter neste comando:

raspistill -o /home/pi/test55.jpg -ex sports --nopreview

Eu inicio um cronômetro de iPhone na frente da câmera. O resultado? 7 segundos, 09 (mas nítido, então a velocidade do obturador etc foi boa, eu não estava obtendo o número desfocado). O que posso fazer para "não" levar X segundos antes de tirar a foto? Vou sincronizar centenas de RPI e não quero que alguns tirem a foto às 4 e outras aos 10 segundos, então eu gostaria de entender o que está acontecendo lá.

Você precisa ter o processo da câmera rodando o tempo todo.

Esta é a única maneira de obter resultados (em média) de 50ms. Procurei por toda parte uma solução. 1 segundo foi muito lento para o meu projeto de sensor de movimento.

O projeto do @Dave Jones me ajudou a descobrir como fazê-lo.

Apenas 2 arquivos:

um daemon, executando o tempo todo e um cliente.

O daemon é onde você define todas as configurações da câmera.

picam-daemon.py

picam-client.py

python picam-daemon.py

import threading
import os, io, base64, time, socket, picamera, daemon
import daemon.runner

MAX_LENGTH = 50 # max length of any possible entry from "client"
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # setup socket
PORT = 10000 # port 10000
HOST = '127.0.0.1' # runs on local host
serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # this allows us to override port, prevents error
serversocket.bind((HOST, PORT)) # lock server to this port and host
serversocket.listen(10) # max 10 clients


# Waits for commands, such as "snap" and "ack"
# Runs over "sockets"
def handle(clientsocket):
    while 1:
        buf = clientsocket.recv(MAX_LENGTH)

        # Receive the SNAP command. Take a picture with PiCam.
        if buf == 'snap':
            start = time.time()
            camera.capture('/home/pi/ir/picam-latest-snap.jpg')
            finish = start - time.time()
            print finish
            print 'Picture Taken!'

        if buf == 'ack':
            print 'Ping: Hello!'

        if len(buf) == 0: break

# Camera is always loaded here
# The "magic" is in the camThread, this allows a picture to be captured, then it gracefully closed the camera connection and reopens it. This produces very fast captures (54ms vs 1.5s!)
while 1:
    # setup camera
    camera = picamera.PiCamera()
    camera.resolution = (640, 480)
    #camera.zoom = (0.2, 0.2, 1.0, 1.0)
    camera.exposure_mode = 'sports'
    print('Camera server running')

    # accept connections from outside, in order to receive commands
    (clientsocket, address) = serversocket.accept()
    ct = threading.Thread(target=handle, args=(clientsocket,))
    ct.run() # this can be run(), because it can be scaled.

    print 'Camera thread starting.'
    camThread = threading.Thread()
    while camThread.is_alive():
        camThread.join(1)
    camThread.run() # this must be start(), otherwise PiCam will crash. This is because PiCam cannot receive more than 1 connection.
    print 'Camera thread ended'
    camera.close() # Gracefully close PiCam if client disconnects

(em um segundo terminal) python picam-client.py

import socket
import sys


HOST = '127.0.0.1'
PORT = 10000
s = socket.socket()
s.connect((HOST, PORT))

print s

while 1:
    msg = raw_input("Command To Send: ")
    if msg == "close":
       s.close()
       sys.exit(0)
    s.send(msg)

Estou postando esta resposta porque a encontrei no Google, tentando encontrar uma resposta. Não consegui encontrar um, então tive que cavar em torno de alguns projetos e inventar alguma coisa.

Você precisa especificar um tempo limite de 0.

Da ajuda da raspistila

-timeout "Time (in ms) before takes picture and shuts down (if not specified, set to 5s)

Para testar quanto tempo um comando leva para executar, você pode usar "time"

time raspistill -o /home/pi/test55.jpg -ex sports --nopreview --timeout 0

Especifiquei o seguinte alias no meu .bash_profile para permitir fotos fáceis e rápidas da câmera:

alias shot='SHOTTIME=$(date +"%Y-%m-%d_%H%M") && raspistill -o shot-$SHOTTIME.jpg --nopreview --exposure sports --timeout 1

Sempre que digito shotna linha de comando, uma imagem com registro de data e hora é salva, por exemplo shot-2016-02-27_0934.jpg.

Você pode querer dar uma olhada no projeto compositepi (divulgação completa: sou o autor). Destina-se a disparar capturas de vários Pi's com módulos de câmera e usa pacotes de transmissão UDP para fazer com que todos sejam disparados o mais próximo possível. Um daemon é executado em cada Pi, que aciona a câmera e dispara capturas ao receber um pacote UDP contendo o comando CAPTURE (outros comandos estão disponíveis para configurar a câmera; o protocolo está bastante bem documentado ). Uma configuração usando Ethernet é ideal, mas o wifi também funcionará, embora você possa ter que usar a funcionalidade de atraso de tempo para obter uma sincronização decente nesse caso (devido à perda de pacotes / latência variável).

Não posso dizer que foi testado com 100 Pi's - no momento, a maior configuração que o envolve envolve 20, mas eu estaria interessado em ouvir sobre qualquer problema que envolva escalas maiores.

O projeto inclui um cliente de linha de comando , um cliente GUI (escrito em Qt, para que funcione no Linux / Mac / Windows, mas só foi testado no Ubuntu neste momento, e ainda não está documentado) e uma biblioteca de cliente baseada em Python para escrevendo trabalhos em lote.