ZoneMinder Forums

Code: Select all

#!/usr/bin/perl -w

# This script has been adapted from utils/zm-alarm.pl to send a notification
# when a monitor has been in an alarm/alert/tape state within the last 3
# seconds. For reference, see:
# scripts/ZoneMinder/lib/ZoneMinder/Memory.pm
#     and
# http://zoneminder.readthedocs.io/en/latest/faq.html#how-can-i-use-zoneminder-to-trigger-something-else-when-there-is-an-alarm
#     and
# https://forums.zoneminder.com/viewtopic.php?t=21781

use strict;
use warnings;
use ZoneMinder;
use DBI;
require MIME::Entity;
use List::Util qw[min max];

$| = 1;

# Interval between monitor checking cycles
my $timeout = 3;

# Length of pause after sending a message (to reduce spam)
our $message_timeout = 1;

# Only send a new event message for a given monitor if it was last detected
# in alarm state more than this many cycles previously. Goal is to prevent
# duplicate messages about the same event. Should be >= 2.
my $alarm_overload_count = 2;   

# Email parameters
our @toaddrs = ("");	# Enter to address(es) here
our $fromaddr = "";	# Enter from address here
our $eventurl = "";	# Enter URL to events page here

my $driver = "mysql";
my $database = "zm";
my $user = "zmuser"; 
my $password = "zmpass";

my @monitors;
my $rebuild_monitors = 1;
while (1) {
        sleep $timeout;

        # Have to exit when ZoneMinder stops running to make sure mapped memory is freed
        my $status = runCommand( "zmdc.pl check" );
        if ( $status ne "running" ) {
                Info( "zm_event_alert.pl is exiting" );
                last;
        }

        # Initialize or re-initialize array of monitors
        if ( $rebuild_monitors ) {
                my $dbh = DBI->connect(
                "DBI:$driver:$database",
                $user, $password,
                ) or die $DBI::errstr;
                
                my $sql = "select M.*, max(E.Id) as LastEventId from Monitors as M left join Events as E on M.Id = E.MonitorId where M.Function != 'None' group by (M.Id)";
                my $sth = $dbh->prepare_cached( $sql ) or die( "Can't prepare '$sql': ".$dbh->errstr() );
                my $res = $sth->execute() or die( "Can't execute '$sql': ".$sth->errstr() );

                @monitors = ();
                while ( my $monitor = $sth->fetchrow_hashref() ) {
                    $monitor->{LastAlarm} = $alarm_overload_count + 1;
                    $monitor->{LastEventId} = zmGetLastEvent( $monitor );
                    $monitor->{Signal} = 1;
                    push( @monitors, $monitor );
                }
        }
        $rebuild_monitors = 0;

        # Loop over monitors
        foreach my $monitor ( @monitors ) {
                if ( !zmMemVerify( $monitor ) ) {
                        $rebuild_monitors = 1;
                        next;
                } 

                # Skip any monitor that is inactive
                if ( !getMonitorActive( $monitor ) ) {
                        next;
                } 

                # Skip any monitor that is not receiving a signal
                my $signal = getMonitorSignal( $monitor );
                if ( !$signal ) {
                        $monitor->{Signal} = $signal;
                        Info("$monitor->{Name} is not sending a signal.");
                        next;
                }

                # Send a message in alarm state if not during previous cycle
                if ( myInAlarm( $monitor ) ) {
                        if ( $monitor->{LastAlarm} > 1 ) {
                                notifyInAlarm( $monitor->{Name} );
                                Info("Sent alarm message for $monitor->{Name}");
                        } 
                        $monitor->{LastAlarm} = 1;
                } else {
                        $monitor->{LastAlarm} = min( $monitor->{LastAlarm} + 1,
                                                     $alarm_overload_count + 1);
                }

                # Send a message if a new event is available, because alarms may
                # not be caught while they are occurring. Try to filter out any
                # events caused by signal loss. Don't send a message if monitor
                # was in alarm state within last alarm_overload_count cycles.
                my $last_event_id = zmGetLastEvent( $monitor );
                my $time = localtime();
                if ( $last_event_id != $monitor->{LastEventId} ) {
                        if ( $monitor->{Signal} and 
                           ( $monitor->{LastAlarm} > $alarm_overload_count ) ) {
                                notifyNewEvent( $monitor->{Name},
                                                $last_event_id );
                                Info("Sent new event $last_event_id alert ".
                                     "for $monitor->{Name}");
                        } elsif ( $monitor->{Signal} ) {
                                Info("$monitor->{Name} event overload count ".
                                     "$monitor->{LastAlarm}");
                        }
                        $monitor->{LastEventId} = $last_event_id;
                }        
                $monitor->{Signal} = $signal;
        }
}

sub getMonitorActive {
        my $monitor = shift;

        return( zmMemRead( $monitor, 'shared_data:active' ) );
}

sub getMonitorSignal {
        my $monitor = shift;

        return( zmMemRead( $monitor, 'shared_data:signal' ) );
}

# Same as zmInAlarm from Memory.pm, but also counts STATE_TAPE as alarm state
sub myInAlarm {
        my $monitor = shift;

        my $state = zmGetMonitorState( $monitor );
        return( $state == 2 || $state == 3 || $state == 4 );
}

sub notifyInAlarm {
        my $monitor_name = shift;

        my $subject = "ZoneMinder alarm";
        my $message = "Monitor $monitor_name is in alarm state!\n".
                      "URL: $eventurl";
        foreach my $toaddr ( @toaddrs ) {
                sendMessage($toaddr, $subject, $message);
        }
}

sub notifyNewEvent {
        my $monitor_name = shift;
        my $last_event_id = shift;

        my $subject = "ZoneMinder alarm";
        my $message = "New event $last_event_id for monitor $monitor_name.\n".
                      "URL: $eventurl";
        foreach my $toaddr ( @toaddrs ) {
                sendMessage($toaddr, $subject, $message);
        }
}

sub sendMessage {
        my $toaddr = shift;
        my $subject = shift;
        my $message = shift;
 
        my $mail = MIME::Entity->build(
                From => $fromaddr,
                To => $toaddr,
                Subject => $subject,
                Type => (($message=~/<html>/)?'text/html':'text/plain'),
                Data => $message
        );
        $mail->smtpsend( Host => "localhost",
                         MailFrom => $fromaddr,
        ); 
        sleep $message_timeout;
}

Code: Select all

#!/usr/bin/perl -w

# This script has been adapted from utils/zm-alarm.pl to send a notification
# within 3 seconds of a new event being generated for a monitor, which occurs
# as soon as motion is detected. The notification includes a link to the frame
# with the highest score, and filters out events caused by signal loss. For
# reference, see:
# scripts/ZoneMinder/lib/ZoneMinder/Memory.pm
#     and
# http://zoneminder.readthedocs.io/en/latest/faq.html#how-can-i-use-zoneminder-to-trigger-something-else-when-there-is-an-alarm
#     and
# https://forums.zoneminder.com/viewtopic.php?t=21781

use strict;
use warnings;
use ZoneMinder;
use DBI;
require MIME::Entity;
use List::Util qw[min max];

$| = 1;

# Interval between monitor checking cycles
my $timeout = 3;

# Pause after sending a message (to reduce spam)
our $message_timeout = 1;

# Min number of cycles after signal loss to send event message. Goal is to
# filter out any events caused by signal loss.
my $signal_overload_count = 5;

# Email parameters. Fill these in! Note that "@" has to be escaped like "\@"
our @toaddrs = ("");
our $fromaddr = "";
our $url = "";

my $driver = "mysql";
my $database = "zm";
my $user = "zmuser"; 
my $password = "zmpass";

my @monitors;
my $rebuild_monitors = 1;
while (1) {
        sleep $timeout;

        # Have to exit when ZoneMinder stops running to make sure mapped memory is freed
        my $status = runCommand( "zmdc.pl check" );
        if ( $status ne "running" ) {
                Info( "zm_event_alert.pl is exiting" );
                last;
        }

        # Initialize or re-initialize array of monitors
        if ( $rebuild_monitors ) {
                my $dbh = DBI->connect("DBI:$driver:$database", $user,
                                       $password) or die $DBI::errstr;
                
                my $sql = "select M.*, max(E.Id) as LastEventId from Monitors as M left join Events as E on M.Id = E.MonitorId where M.Function != 'None' group by (M.Id)";
                my $sth = $dbh->prepare_cached( $sql ) or die( "Can't prepare '$sql': ".$dbh->errstr() );
                my $res = $sth->execute() or die( "Can't execute '$sql': ".$sth->errstr() );

                @monitors = ();
                while ( my $monitor = $sth->fetchrow_hashref() ) {
                    $monitor->{LastEventId} = zmGetLastEvent( $monitor );
                    $monitor->{LastSignal} = $signal_overload_count + 1;
                    push( @monitors, $monitor );
                }
        }
        $rebuild_monitors = 0;

        # Loop over monitors
        foreach my $monitor ( @monitors ) {
                if ( !zmMemVerify( $monitor ) ) {
                        $rebuild_monitors = 1;
                        next;
                } 

                # Skip any monitor that is inactive
                if ( !getMonitorActive( $monitor ) ) {
                        next;
                } 

                # Skip any monitor that is not receiving a signal
                my $signal = getMonitorSignal( $monitor );
                if ( !$signal ) {
                        $monitor->{LastSignal} = 1;
                        Info( "$monitor->{Name} is not sending a signal." );
                        next;
                } else {
                        $monitor->{LastSignal} = min( $monitor->{LastSignal} + 1,
                                                      $signal_overload_count + 1 );
                }

                # Send a message if a new event is available. Try to filter out
                # any events caused by signal loss.
                my $last_event_id = zmGetLastEvent( $monitor );
                if ( $last_event_id != $monitor->{LastEventId} ) {
                        if ( $monitor->{LastSignal} <= $signal_overload_count ) {
                                Info( "$monitor->{Name} signal overload count ".
                                      "$monitor->{LastSignal}" );
                        } else {
                                notifyNewEvent( $monitor->{Name},
                                                $last_event_id );
                                Info( "Sent new event $last_event_id alert ".
                                      "for $monitor->{Name}" );
                        }
                        $monitor->{LastEventId} = $last_event_id;
                }        
        }
}

sub getMonitorActive {
        my $monitor = shift;

        return( zmMemRead( $monitor, 'shared_data:active' ) );
}

sub getMonitorSignal {
        my $monitor = shift;

        return( zmMemRead( $monitor, 'shared_data:signal' ) );
}

sub notifyNewEvent {
        my $monitor_name = shift;
        my $last_event_id = shift;

        my $subject = "ZoneMinder alarm";
        my $maxscore_url = $url . "/index.php?view=frame&eid=".
                           $last_event_id . "&fid=0";
        my $message = "New event $last_event_id for monitor $monitor_name.\n".
                      "URL: $maxscore_url";
        foreach my $toaddr ( @toaddrs ) {
                sendMessage($toaddr, $subject, $message);
        }
}

sub sendMessage {
        my $toaddr = shift;
        my $subject = shift;
        my $message = shift;
 
        my $mail = MIME::Entity->build(
                From => $fromaddr,
                To => $toaddr,
                Subject => $subject,
                Type => (($message=~/<html>/)?'text/html':'text/plain'),
                Data => $message
        );
        $mail->smtpsend( Host => "localhost",
                         MailFrom => $fromaddr,
        );
        sleep $message_timeout; 
}

Code: Select all

#!/bin/bash
#
# If ZoneMinder is running, checks if zm_event_alert.pl is running and starts it
# if not.
#

get_pid()
{
  echo $(pgrep -f \/usr\/local\/bin\/zm_event_alert\.pl)
}

INTERVAL=30
while [ 1 ]; do
  STATUS=$(zmpkg.pl status)
  if [ "$STATUS" == "running" ]; then
    ZM_ALERT_PID=$(get_pid)
    if [ -z "$ZM_ALERT_PID" ]; then
      /usr/local/bin/zm_event_alert.pl &
    fi
  fi
  sleep $INTERVAL
done

Code: Select all

my $dbh = zmDbConnect();

Code: Select all

# Directory for images to be attached:
my $imageDir = '/dev/shm/' ;
# Where to write the current image from the monitor determined to be in alarm:
my $imagePath = "$imageDir".'Monitor'."$monitor->{Id}".'.jpg' ;
# Make sure any old image from previous messages is deleted:
system ("rm $imagePath &> /dev/null");
# Call the zmu utility to write the current image from the monitor determined to be in alarm:
system ("cd $imageDir && exec zmu -m $monitor->{Id} -i -U ***** -P *********");
# Check to make sure that the image is written before sending the message:
my $imageExists = undef ;
while (!$imageExists) {
$imageExists = ( -s $imagePath );
 }

Code: Select all

foreach my $monitor (@monitors) {               
# use zmMemVerify method to get memory handle for monitor or test that my handle is good
                my $monitorMemverify = zmMemVerify($monitor);
# if I successfully got a memory handle, flag the monitor as having a good memory handle and execute my code                
                if ($monitorMemverify) {
                	$monitor->{MemExists} = 1 ;
 ++++++++++++++++++++++++++++++++++++++++++++++++
              . . . Do my stuff here . . .
 ++++++++++++++++++++++++++++++++++++++++++++++++              
# if I have a bad memory handle, release the handle & unset flag so we do not to try to release a non-existant handle
                 elsif ($monitor->{MemExists}) {
	                 zmMemInvalidate($monitor) ;
        	         $monitor->{MemExists} = undef ;
                }
       }

Code: Select all

#!/usr/bin/perl -w

# This script has been adapted from utils/zm-alarm.pl to send a notification
# within 3 seconds of a new event being generated for a monitor, which occurs
# as soon as motion is detected. The notification includes a link to the frame
# with the highest score, and filters out events caused by signal loss. For
# reference, see:
# scripts/ZoneMinder/lib/ZoneMinder/Memory.pm
#     and
# http://zoneminder.readthedocs.io/en/latest/faq.html#how-can-i-use-zoneminder-to-trigger-something-else-when-there-is-an-alarm
#     and
# https://forums.zoneminder.com/viewtopic.php?t=21781

use strict;
use warnings;
use ZoneMinder;
# require MIME::Entity; # Only used for old email method
use DBI;
use List::Util qw[min max];

$| = 1;

Info( "zm_event_alert.pl has started" );

# Interval between monitor checking cycles
my $timeout = 3;

# Pause after sending a message (to reduce spam)
our $message_timeout = 1;

# Min number of cycles after signal loss to send event message. Goal is to
# filter out any events caused by signal loss.
my $signal_overload_count = 5;

# Email parameters
our @toaddrs = ("");
our $url = "";
our $ssmtp_location = "";
our $tmp_message_file = "/tmp/zm_event_email.txt";

my $driver = "mysql";
my $database = "zm";
my $user = "zmuser";
my $password = "zmpass";

my $rebuild_monitors = 1;
my $time_to_exit = 0;
my @monitors;
while (1) {
        sleep $timeout;
        if ( $time_to_exit ) {
                system( "/usr/local/bin/zm_event_alert_watcher.sh &" );
                last;
        }

        # Initialize array of monitors
        if ( $rebuild_monitors ) {
                Info( "Rebuilding monitors list" );
                my $dbh = DBI->connect("DBI:$driver:$database", $user,
                                       $password) or die $DBI::errstr;

                my $sql = "select M.*, max(E.Id) as LastEventId from Monitors as M left join Events as E on M.Id = E.MonitorId where M.Function != 'None' group by (M.Id)";
                my $sth = $dbh->prepare_cached( $sql ) or die( "Can't prepare '$sql': ".$dbh->errstr() );
                my $res = $sth->execute() or die( "Can't execute '$sql': ".$sth->errstr() );

                @monitors = ();
                while ( my $monitor = $sth->fetchrow_hashref() ) {
                    $monitor->{LastEventId} = zmGetLastEvent( $monitor );
                    $monitor->{LastSignal} = $signal_overload_count + 1;
                    push( @monitors, $monitor );
                }
        }
        $rebuild_monitors = 0;

        # Loop over monitors
        foreach my $monitor ( @monitors ) {
                if ( !zmMemVerify( $monitor ) ) {
                        # Exit to release shared memory -> watcher daemon will start it up again if needed
                        Info( "zm_event_alert.pl is exiting due to invalid monitor" );
                        $time_to_exit = 1;
                        last;
                }

                # Skip any monitor that is inactive
                if ( !getMonitorActive( $monitor ) ) {
                        next;
                }

                # Skip any monitor that is not receiving a signal
                my $signal = getMonitorSignal( $monitor );
                if ( !$signal ) {
                        $monitor->{LastSignal} = 1;
                        Info( "$monitor->{Name} is not sending a signal" );
                        next;
                } else {
                        $monitor->{LastSignal} = min( $monitor->{LastSignal} + 1,
                                                      $signal_overload_count + 1 );
                }
                
                # Send a message if a new event is available. Try to filter out
                # any events caused by signal loss.
                my $last_event_id = zmGetLastEvent( $monitor );
                if ( $last_event_id != $monitor->{LastEventId} ) {
                        if ( $monitor->{LastSignal} <= $signal_overload_count ) {
                                Info( "$monitor->{Name} signal overload count ".
                                      "$monitor->{LastSignal}" );
                        } else {
                                notifyNewEvent( $monitor->{Name},
                                                $last_event_id );
                                Info( "Sent new event $last_event_id alert ".
                                      "for $monitor->{Name}" );
                        }
                        $monitor->{LastEventId} = $last_event_id;
                }
        }
}

sub getMonitorActive {
        my $monitor = shift;

        return( zmMemRead( $monitor, 'shared_data:active' ) );
}

sub getMonitorSignal {
        my $monitor = shift;

        return( zmMemRead( $monitor, 'shared_data:signal' ) );
}

sub notifyNewEvent {
        my $monitor_name = shift;
        my $last_event_id = shift;

        my $subject = "ZoneMinder alarm";
        my $maxscore_url = $url . "/index.php?view=frame&eid=".
                           $last_event_id . "&fid=0";
        my $message = "New event $last_event_id for monitor $monitor_name.\n".
                      "URL: $maxscore_url";

        writeMessage( $subject, $message );
        foreach my $toaddr ( @toaddrs ) {
                sendMessage( $toaddr );
        }
}

               sub writeMessage {
        my $subject = shift;
        my $message = shift;

        open( my $fh, '>', $tmp_message_file );
        print $fh "Subject: $subject\n\n";
        print $fh "$message\n";
        close( $fh );
}

sub sendMessage {
        my $toaddr = shift;

        system( "$ssmtp_location -a default $toaddr < $tmp_message_file" );
}