Build a machine-vision inspection that survives a production line: choosing what vision can actually do, the In-Sight spreadsheet, locating and fixturing, the ViDi deep-learning tools, getting the result to a PLC without reading a stale one, and the lighting that decides whether any of it works.
About this course
Ten modules, an hour of material and an hour of hands-on work each, which is three and a half days end to end.
It opens with the module most vision courses leave out: what a camera can and cannot do, and the pixel arithmetic that tells you before you quote the job. Vision attracts more magical thinking than any other part of automation, and most failed projects were unwinnable on day one.
Then the In-Sight system itself, a self-contained smart camera whose programming model is a spreadsheet, which surprises everyone arriving from ladder. Acquisition, exposure against motion blur, and locating the part so that every later inspection can be fixtured to where it actually turned out to be. That one idea is the difference between a job that works on the bench and a job that works on the line.
The middle of the course is the toolset: combining results into a single verdict with thresholds set from measured data, then the ViDi deep-learning tools: Detect for defects you cannot write a rule for, Check for classification and layout, Read for marking that classic OCR gives up on. Each gets equal weight on how to train it and on how to tell when it has learned the wrong thing.
The last three modules are what makes it a system rather than a demo: discrete I/O and EtherNet/IP to a Rockwell PLC or PROFINET to an S7, with the handshake that stops the PLC reading the previous part’s verdict; the operator interface and the deployment and backup that let somebody else maintain it; and finally lighting and optics, which is taught last and designed first.
What you work through
Where a vision system earns its place and where it will disappoint, how a camera turns a scene into pixels, resolution against field of view, and why the answer to most vision problems is the lighting.
The camera, the software and the network between them: addressing an In-Sight on a subnet you control, the device pane, and the emulator that lets you work with no camera in front of you.
How the spreadsheet actually runs, AcquireImage and what feeds it, exposure and gain against motion, and reading a cell reference rather than guessing at one.
Pattern matching that survives rotation, scale and lighting change, why almost every inspection starts by locating the part, and fixturing the rest of the tools to what PatMax found.
Turning tool outputs into one answer with spreadsheet logic, building a result a machine can act on, and why the decision belongs in the job rather than in the PLC.
Where deep learning beats a written rule, labelling a training set honestly, masks and regions, reading the result statistics, and knowing when you have taught it the wrong thing.
Classifying what is present against a layout model, reading text the classic OCR tools cannot, regex models, and choosing between a deep-learning tool and a classic one.
Triggering, discrete I/O timing, EtherNet/IP to a Rockwell PLC and PROFINET to an S7, what the assembly data actually carries, and the handshake that stops you reading a stale result.
Building a web HMI an operator can actually use, what to expose and what to lock, then deploying: firmware, job storage, backups, and handing over a camera somebody else has to maintain.
Bright field, dark field, backlight and diffuse dome, choosing a lens from working distance and field of view, depth of field, and why this module is last but gets designed first.
Lab times are approximate: they are a guide to how long the hands-on part usually takes, not a limit. You can ask for more lab time whenever you need it.
All ten module decks are written and can be read now. Procedures are taught as illustrated sequences: what the spreadsheet looks like, what the tool is looking at, what the result means, so the material can be followed without a camera in front of you.
What is not here yet is the hardware. There is no In-Sight camera in the lab, so the hands-on hour listed against each module cannot be booked and the knowledge checks are still being written. Reading an inspection procedure is not the same as having built one, and this course does not pretend otherwise.
Two things are worth knowing before you plan around this. In-Sight can run an emulator on a PC, which is genuinely the best way to learn the software without a camera, but the emulator needs a Cognex licence, and so do the ViDi tools. Neither is a free download. And an emulator replaces the processor, not the physics: it cannot teach you whether your lighting works.
The course is written against Cognex In-Sight with the ViDi tools. The first two modules and the lighting and optics module transfer to any machine-vision system; the spreadsheet, the tool names and the screens do not.