Interfaçage dynamique caméra industrielle

**colorid** · 19/08/2011, 15h36

Bonjour à tous les forumers,

L'un de vous peut-il me fournir des info sur l'interfaçage dynamique d'une caméra industrielle ?

J'entend par interface dynamique le fait que l'on pilote entièrement la caméra à partir du code delphi. Pas de shell exe pour lancer un exécutable propriétaire.

La résolution peut être faible, le type VGA suffit pour l'appli envisagée.

Si oui :
Quelle marque ?
Quel modêle ?
Quel fournisseur ou distributeur ?
Un exemple de code Delphi bien entendu.

**Hololab** · 26/08/2011, 23h03

Salut,

j'utilise une camera Vineon car elle est fournie avec une unité delphi (qui n'est qu'une interface avec une dll), et de nombreux exemples. Le SDK est gratuit.

La caméra m'a couté 240€ sans objectif (1280*1024).

Ils ont des camera CCD et CMOS, depuis le simple VGA jusque 5MP.

C'est ici : http://www.vineon.net/

En espérant que ça t'es utile.

@+

**colorid** · 27/08/2011, 14h40

celà m

**ShaiLeTroll** · 29/08/2011, 10h55

Le problème c'est qu'il y a autant d'API que de fabricant et pire même plusieurs API selon le modèle !

Soit tu axes ta solution sur un modèle unique avec les risques de pénurie et de changement d'API pour les modèles suivants.
Hololab ayant proposé Vineon, on peut penser qu'il a une bonne expérience avec ... dommage que tu n'as pas un essai gratuit !

Lorsque tu parles de pilotage, hormis la configuration de la résolution, la fréquence des images, ... les caméras sont peu configurable si utilisé via le port VGA car dédié à la vidéo, très peu supporte le contrôle VESA.
Même tu devais surement désigné VGA comme standard de résolution,

Soit tu utilises des Caméras IP qui ne sont pas considérés comme sécurisées, bcp fournissent un serveur Web accessible en HTTP mais pas HTTPS, le passage des données par des nombreux switch\routeur (et les risques d'interception) en clair n'est pas considérée comme sécurisée non plus

Soit tu passes par des Caméras Analogiques ou Numériques connectés sur un DVR (qui lui fournira une API de contrôle de 4 à 32, voire même 64 caméras sur un seul appareil, le prix grimpant notablement au passage !
Le DVR garantit un TimeStamp des images non modifiables et la moindre anomalie de signal est noté dans l'historique pouvant indiquer des tentatives d'interception (souvent évité par des cables blindés)

Je débute la vidéosurveillance, je suis en plein dedans et j'utilise des caméras InfraRouge avec détection de mouvement et totalement orientable (motorisée), le cablage étant adapté (ça c'est mon collègue qui me l'a fait)

**colorid** · 29/08/2011, 12h32

je débute en application de vision industrielle, j'ai réalisé un proto avec une webcam interfcée par la dll cam32. Je souhaite utiliser une caméra industrielle interfacée sous delphi.

merci pour vos info

colorid

**ShaiLeTroll** · 29/08/2011, 13h53

Comme je l'ai dit, cela dépend du fabricant, tant que tu ne décides pas pour un produit, difficile d'en dire plus, à chaque appareil un protocole spécifique, certains utilisent les MIB pour leur configuration puis un server HTTP plus le flux H264, JpegMotion ...

Les WebCam sont standardisées, c'est ce qui fait que c'est une WebCam, pour le reste c'est de l'intégration matérielle, il faut utiliser les API !

Perso, j'utilise des appareils dont les prix varient entre 1000 et 5000€ l'unité et mon expérience est trop limité pour le moment pour que je puisse conseiller modèle ou marque

**annemarie** · 29/08/2011, 15h32

Certains fournisseurs encapsulent les streams dans des protocoles propriétaires, d'autres les caches mais on peut voir les adresses avec un sniffer réseaux. On en trouve aussi qui streame en rtsp.

**Hololab** · 29/08/2011, 19h25

Bonjour,

c'est vrai qu'aucun constructeur ne garantira une continuité dans les API, mais c'est vrai pour les caméras aussi.

J'ai moi aussi commencé avec une WebCam et les VCL VideoLab de Mitov Software, mais on en a pour son argent (c'est à dire rien,...).

Mon cahier des charges :
- application scientifique avec quelques dizaines de caméras tout au plus
- vu mon faible niveau en programmation, utilisable en Delphi 6 sans écrire le moindre bout de code pour transtyper des data venues du monde obscur du C
- disponible en N&B
- dynamique d'au moins 10 bits
- disposant d'un mode RAW pour être certain de ne pas avoir une moulinette qui modifie les données du capteur
- couche physique peu importante, USB convient très bien.
- disponibilité d'un mode trigger hardware et de quelques I/O pour interfacer une roue à filtres (pas fondamental car on peut passer par une carte I/O, mais si c'est built-in, c'est plus simple à gérer)

Seul Vineon m'a garanti ces éléments. J'aurais préféré des partenaires plus établis sur le domaine (comme Imaging Source par exemple).

Pour info, voici l'API fournie, c'est une dll qui wrappe les fonctions C vers une définition Delphi (il y a d'autres fonctions non documentées que j'ai trouvées avec un dll viewer, mais que je n'ai pas essayées) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
unit uctools;
 
interface
uses Windows;
 
const vformat: array[0..6, 0..4] of string =
               (('752 x 480','','','',''),
                ('752 x 480','','','',''),
                ('1280 x 1024','640 x 512','640 x 480 ROI','320 x 240 ROI',''),
                ('2048 x 1536','1024 x 768','640 x 480','512 x 384','1280 x 1024 ROI'),
                ('2592 x 1944','1280 x 960','1024 x 768','640 x 480','1280 x 1024 ROI'),
                ('1024 x 768','','','',''),
                ('1360 x 1024','','','',''));
 
 
type PARAMETER =
(
		PARAMETER_1 = 0,
		PARAMETER_2 = 1,
		PARAMETER_3 = 2,
		PARAMETER_4 = 3
);
 
type DS_FILE_TYPE =
(
		FILE_JPG = 1,
		FILE_BMP = 2,
		FILE_RAW = 4
);
 
 
const para: array[0..3] of PARAMETER = (PARAMETER_1,PARAMETER_2,PARAMETER_3,PARAMETER_4);
 
type UC_RUNMODE =
(
		RUNMODE_PLAY=0,
		RUNMODE_PAUSE=1,
		RUNMODE_STOP=2
);
 
//***********************************************************************************************
function SoftTrigger() : Shortint	; stdcall;
function GetCamNumber(var camno:byte)  : Shortint	; stdcall;
function CameraWriteSerial(var Sn : byte; len : byte): Shortint; stdcall;
function CameraReadSerial(var Sn : byte): Shortint; stdcall;
function CameraGetMultiCameraNumber(var CamTotal : byte):shortint; stdcall;
function CameraUnInit() : Shortint; stdcall	;
function InitCamera(callback:pointer;callback_mode,res:integer; twnd :hwnd;c : Pointer;CamNum : byte) : Shortint	;  stdcall;
function  CameraPlay(value : byte) : Shortint	; stdcall;
function  CameraStop() : Shortint	; stdcall;
function  set_runmode(runmode:UC_RUNMODE) : Shortint	; stdcall;
function  CameraGetImageSize(var pWidth, pHeight:  integer	) : Shortint	; stdcall;
function  Get_ImageBuffer(var tim :PBYTE) : Shortint	; stdcall;
function  Get_ProcImage(var tim :pbyte) : Shortint	; stdcall;
function  Get_GrabStopImage(var tim :pbyte) : Shortint	; stdcall;
function  CameraCaptureFile(filename : string;filetype : byte) : Shortint	; stdcall;
function  CameraSetAeState(state : bool) : Shortint	; stdcall;
function  CameraGetAeState(var state : bool) : Shortint	; stdcall;
function  CameraSaveParameter(group : PARAMETER ) : Shortint	; stdcall;
function  CameraReadParameter(group : PARAMETER ) : Shortint	; stdcall;
function  CameraGetCurrentParameterTeam(var group : byte) : Shortint	; stdcall;
function  CameraSetAeTarget(value : byte) : Shortint	; stdcall;
function  CameraGetAeTarget(var value : byte) : Shortint	; stdcall;
function  CameraSetExposureTime(value : integer) : Shortint	; stdcall;
function  CameraGetExposureTime(var value : integer) : Shortint	; stdcall;
function  CameraSetAnalogGain(value : integer) : Shortint	; stdcall;
function  CameraGetAnalogGain(var value : integer) : Shortint	; stdcall;
function  CameraSetGamma(value : byte) : Shortint	; stdcall;
function  CameraGetGamma(var value : byte) : Shortint	; stdcall;
function  CameraSetContrast(value : byte) : Shortint	; stdcall;
function  CameraGetContrast(var value : byte) : Shortint	; stdcall;
function  CameraSetFrameSpeed(value : byte) : Shortint	; stdcall;
function  CameraGetFrameSpeed(var value : byte) : Shortint	; stdcall;
function  CameraGetBitmap(PData: pbyte;flipmode : byte): Shortint; stdcall;
function  CameraCopyBitmap(srcData: pbyte;PData: pbyte): Shortint; stdcall;
function  CameraSetMirror(direction : byte; state : bool) : Shortint; stdcall;
function  CameraGetLightFrquency(var value:byte):ShortInt; stdcall;
 
//*****************************************************************************
function  SoftTrigger() : Shortint	; stdcall;  external 'uc1311.dll' name 'CameraSoftTriggerStart';
function  GetCamNumber(var camno:byte)  : Shortint	; stdcall; external 'uc1311.dll' name 'CameraGetMultiCameraNumber';
function  CameraWriteSerial(var Sn : byte; len : byte): Shortint; stdcall;  external 'uc1311.dll' name 'CameraWriteSerial';
function  CameraReadSerial(var Sn : byte): Shortint; stdcall;  external 'uc1311.dll' name 'CameraReadSerial';
function  CameraGetMultiCameraNumber(var CamTotal : byte): Shortint; stdcall;  external 'uc1311.dll' name 'CameraGetMultiCameraNumber';
function  CameraUnInit() : Shortint	; stdcall;  external 'uc1311.dll' name 'CameraUnInit';
function  InitCamera(callback:pointer;callback_mode,res:integer;twnd :hwnd;c : Pointer;CamNum : byte) : Shortint	; stdcall;  external 'uc1311.dll' name 'CameraInit';
function  CameraPlay(value : byte) : Shortint	; stdcall; external 'uc1311.dll' name 'CameraPlay';
function  CameraStop() : Shortint	; stdcall; external 'uc1311.dll' name 'CameraStop';
function  set_runmode(runmode:UC_RUNMODE) : Shortint	; stdcall;  external 'uc1311.dll' name 'set_runmode';
function  CameraGetImageSize(var pWidth,pHeight: integer	) : Shortint	; stdcall; external 'uc1311.dll' name 'CameraGetImageSize';
function  Get_ImageBuffer(var tim :pbyte) : Shortint	; stdcall; external 'uc1311.dll' name 'Get_ImageBuffer';
function  Get_ProcImage(var tim :pbyte) : Shortint	; stdcall; external 'uc1311.dll' name 'Get_ProcImage';
function  Get_GrabStopImage(var tim :pbyte) : Shortint	; stdcall; external 'uc1311.dll' name 'Get_GrabStopImage';
function  CameraCaptureFile(filename : string;filetype : byte) : Shortint	; stdcall; external 'uc1311.dll' name 'CameraCaptureFile';
function  CameraSetAeState(state : bool) : Shortint	; stdcall; external 'uc1311.dll' name 'CameraSetAeState';
function  CameraGetAeState(var state : bool) : Shortint	; stdcall; external 'uc1311.dll' name 'CameraGetAeState';
function  CameraSaveParameter(group : PARAMETER ) : Shortint	; stdcall; external 'uc1311.dll' name 'CameraSaveParameter';
function  CameraReadParameter(group : PARAMETER ) : Shortint	; stdcall; external 'uc1311.dll' name 'CameraReadParameter';
function  CameraGetCurrentParameterTeam(var group : byte) : Shortint	; stdcall; external 'uc1311.dll' name 'CameraGetCurrentParameterTeam';
function  CameraSetAeTarget(value : byte) : Shortint	; stdcall; external 'uc1311.dll' name 'CameraSetAeTarget';
function  CameraGetAeTarget(var value : byte) : Shortint	; stdcall; external 'uc1311.dll' name 'CameraGetAeTarget';
function  CameraSetExposureTime(value : integer) : Shortint	; stdcall; external 'uc1311.dll' name 'CameraSetExposureTime';
function  CameraGetExposureTime(var value : integer) : Shortint	; stdcall; external 'uc1311.dll' name 'CameraGetExposureTime';
function  CameraSetAnalogGain(value : integer) : Shortint	; stdcall; external 'uc1311.dll' name 'CameraSetAnalogGain';
function  CameraGetAnalogGain(var value : integer) : Shortint	; stdcall; external 'uc1311.dll' name 'CameraGetAnalogGain';
function  CameraSetFrameSpeed(value : byte) : Shortint	; stdcall; external 'uc1311.dll' name 'CameraSetFrameSpeed';
function  CameraGetFrameSpeed(var value : byte) : Shortint	; stdcall; external 'uc1311.dll' name 'CameraGetFrameSpeed';
function  CameraSetGamma(value : byte) : Shortint	; stdcall; external 'uc1311.dll' name 'CameraSetGamma';
function  CameraGetGamma(var value : byte) : Shortint	; stdcall; external 'uc1311.dll' name 'CameraGetGamma';
function  CameraSetContrast(value : byte) : Shortint	; stdcall; external 'uc1311.dll' name 'CameraSetContrast';
function  CameraGetContrast(var value : byte) : Shortint	; stdcall; external 'uc1311.dll' name 'CameraGetContrast';
function  CameraGetBitmap(PData: pbyte;flipmode : byte) : Shortint	; stdcall; external 'uc1311.dll' name 'CameraGetBitmap';
function  CameraCopyBitmap(srcData: pbyte;PData: pbyte) : Shortint	; stdcall; external 'uc1311.dll' name 'CameraCopyBitmap';
function  CameraSetMirror(direction : byte; state : bool) : Shortint	; stdcall; external 'uc1311.dll' name 'CameraSetMirror';
function  CameraGetLightFrquency(var value:byte):ShortInt               ; stdcall; external 'uc1311.dll' name 'CameraGetLightFrquency';
 
//*************************************************************************************************************
 
var
uc_video_mode : byte;
 
implementation
 
end.

Il y a aussi un mode compatible ActiveX, mais je n'ai pas compris l'intérêt du choix de cette couche logicielle.

Et en cadeau, la doc support de programmation fournie.

Voilà, j'espère que ça te sera utile.

@+

**Hololab** · 29/08/2011, 19h27

Envoyé par ShaiLeTroll

Hololab ayant proposé Vineon, on peut penser qu'il a une bonne expérience avec ... dommage que tu n'as pas un essai gratuit !...

On n'est pas très loin, si tu veux tu peux venir au labo et essayer la caméra.

@+

**Andnotor** · 29/08/2011, 22h32

Envoyé par colorid

j'ai réalisé un proto avec une webcam interfcée par la dll cam32. Je souhaite utiliser une caméra industrielle interfacée sous delphi.

Le problème est que cette définition ne nous en dit toujours pas plus

Lorsque j'entends parler de "vision industrielle", j'ai plutôt tendance à penser : "Reconnaissance de formes" ou "code barres" (et là je comprendrais l'utilisation de Delphi) et non : "vidéo surveillance" (où tout existe).