Апгрейд Windows с помощью SCCM 2016
Сергей Болдин


SELECT SMS_R_System.NetbiosName, SMS_R_System.OperatingSystemNameandVersion
FROM SMS_R_System
WHERE SMS_R_System.OperatingSystemNameandVersion like "%Workstation 10.0%"
  
-----------------------------------------------------------------------------------------

Инфраструктура открытых ключей в Windows Server 2016. Часть 4. Сетевой ответчик
Степан Москалев, Леонид Шапиро


Add-CAAuthorityInformationAccess http://pki.nwtraders.msft/ocsp -AddToCertificateOcsp -Force



Restart-Service CertSvc



Install-WindowsFeature ADCS-Online-Cert –IncludeManagementTools



Install-ADcsOnlineResponder



nwtraders/Administrator
  
-----------------------------------------------------------------------------------------

Аналитическое моделирование в 1С многоканальной системы массового обслуживания
Кирилл Ткаченко


Функция СМО(K, N, lam, mu)
	Перем rho, rhos;
	Перем p0, potk;
	Перем Kz;
	Перем Wq, Tq;
	Перем Ws, Ts;
	Перем psost;
	Перем i, j;
	Перем Числ, Знам;
	Перем KФакт;
	Перем ТЕРМИНАТОР;
	Перем Рез;



	ТЕРМИНАТОР = ""
		"";



	rho = lam / mu;
	Рез = "rho = " + Формат(rho, "ЧДЦ=4") + ТЕРМИНАТОР;



	rhos = rho / K;
	Рез = Рез + "rho_s = " + Формат(rhos, "ЧДЦ=4") + ТЕРМИНАТОР;



	p0 = 1;
	Числ = 1;
	Знам = 1;
	Для j = 1 По K - 1 Цикл
		Числ = Числ * rho;
		Знам = Знам * j;
		p0 = p0 + Числ / Знам;
	КонецЦикла;
	Числ = Числ * rho * (1 - Pow(rhos, N + 1));
	KФакт = Знам * K;
	p0 = p0 + Числ / (KФакт * (1 - rhos));
	p0 = 1 / p0;
	Рез = Рез + "p0 = " + Формат(p0, "ЧДЦ=4") + ТЕРМИНАТОР;



	potk = (Pow(rho, K + N) * p0) / (KФакт * Pow(K, N));
	Рез = Рез + "potk = " + Формат(potk, "ЧДЦ=4") + ТЕРМИНАТОР;



	Kz = rho * (1 - potk);
	Рез = Рез + "Kz = " + Формат(Kz, "ЧДЦ=4") + ТЕРМИНАТОР;
	Wq = (Pow(rho, K + 1) * p0) / (KФакт * K);
	Wq = Wq * (1 - Pow(rhos, N) * (N + 1 - N * rhos)) / Pow(1 - rhos, 2);
	Рез = Рез + "Wq = " + Формат(Wq, "ЧДЦ=4") + ТЕРМИНАТОР;
	Tq = Wq / lam;
	Рез = Рез + "Tq = " + Формат(Tq, "ЧДЦ=4") + ТЕРМИНАТОР;
	Ws = Wq + Kz;
	Рез = Рез + "Ws = " + Формат(Ws, "ЧДЦ=4") + ТЕРМИНАТОР;
	Ts = Tq + (1 - potk) / mu;
	Рез = Рез + "Ts = " + Формат(Ts, "ЧДЦ=4") + ТЕРМИНАТОР;
	
	
	
	Числ = p0;
	Знам = 1;
	Для i = 1 По K Цикл
		Числ = Числ * rho;
		Знам = Знам * i;
		psost = Числ / Знам;
		Рез = Рез + "p" + i + " = " + Формат(psost, "ЧДЦ=4") + ТЕРМИНАТОР;
	КонецЦикла;
	
	
	
	Для i = K + 1 По K + N - 1 Цикл
		Числ = Числ * rho;
		Знам = Знам * K;
		psost = Числ / Знам;
		Рез = Рез + "p" + i + " = " + Формат(psost, "ЧДЦ=4") + ТЕРМИНАТОР;
	КонецЦикла;
	
	
	
	Возврат Рез;
КонецФункции



Сообщить(СМО(4, 7, 30, 17));
  
-----------------------------------------------------------------------------------------

Что должен знать и уметь системный администратор. Часть 4. Настройка железа
Сергей Болдин


750_(config)#
interface port-channel1
description ---Link to ESXi---
switchport trunk encapsulation dot1q
switchport trunk allowed vlan 5-13
switchport mode trunk



750_(config)#
interface Gi1/0/8
switchport trunk encapsulation dot1q
switchport trunk allowed vlan 5-13
switchport mode trunk
channel-group 1 mode on
  
-----------------------------------------------------------------------------------------

Реализация Telnet-клиента в прикладной программе для удаленного управления телекоммуникационным оборудованием от разных производителей
Муллабаев В.Н.


use Net::Telnet;
my $remotehost=$ARGV[0] ;
my $username=$ARGV[1];
my $passwd=$ARGV[2];
my $cmd=$ARGV[3];
my $telnet = new Net::Telnet (Timeout => 10, Prompt => '/[\$%#>] $/');
$telnet->open("$remotehost");
$telnet->login($username, $passwd);
@lines = $telnet->cmd("$cmd");
print @lines;



perl p_comp.pl server1 'имя' 'пароль' '/usr/bin/w'



 use Net::Telnet::Cisco;
 my $remotehost=$ARGV[0] ;
my $username=$ARGV[1];
my $passwd=$ARGV[2];
my $enable_passwd=$ARGV[3];
my $cmd=$ARGV[4];
  my $session = Net::Telnet::Cisco->new(Host => "$remotehost");
  $session->login($username, $passwd);
if ($session->enable($enable_passwd) ) {
      @output = $session->cmd("$cmd");
      print "Текущая конфигурация: @output\n";
  } else {
      warn "Невозможно перейти в режим enable : " . $session->errmsg;
  }
  $session->close;



perl p_cisco.pl router1 'имя' 'пароль1' 'пароль2' 'show running-config'



use Net::Telnet;
 my $telnet = new Net::Telnet (Timeout=>10, Errmode=>'die', Prompt=>'/\w+(?=>)|\w+(?=#)/');
my $remotehost=$ARGV[0] ;
my $username=$ARGV[1];
my $passwd=$ARGV[2];
my $enable_passwd=$ARGV[3];
my $cmd=$ARGV[4];
$telnet->open("$remotehost");

############ Авторизация ##############
$telnet->waitfor('/\w+(?=:)/');
$telnet->print(“$username\n”);
$telnet->waitfor('/\w+(?=:)/');
$telnet->print(“$passwd\n");
$telnet->waitfor('/\w+(?=>)/');
$telnet->print("enable 15\n");
$telnet->waitfor('/\w+(?=:)/');
$telnet->print(“$enable_passwd \n");
$telnet->waitfor('/\w+(?=#)/');
$telnet->print("config t\n");
$telnet->waitfor('/\w+\)(?=#)/');

############ Посылка команды ############
$telnet->cmd_remove_mode(3);
$telnet->buffer_empty;
@chars = split(//, $cmd);
for($i=0; $i < @chars; $i++) {
	$telnet->put("$chars[$i]");
	sleep(1) if $chars[$i] eq '0';
	}
$telnet->put("\n");
while($a=$telnet->getline){
	last if ($a =~ /$cmd/);
}

########### Получение ответа ############
a: while($myl = $telnet->get(Timeout=>5)){
	if ($myl =~ /<cr>/) { $telnet->print("\n"); }
        elsif ( $myl =~ /More/ ) { $telnet->print(" "); }
	elsif ($myl =~ /config\)#$/) {last a;}
	else { print("$myl"); }
    }

print "\n";
$telnet->close("$remotehost");
  
-----------------------------------------------------------------------------------------

Применение SCADA-технологий к системе автоматизации химико-технологических процессов алюминия хлоргидрата
Романенков А.М.


count = 20000;
X= 1:count-1;
B=0;
cnt=1;
while count~=cnt
    [V,N] = fread(fid, 1, 'double');
    if N > 0
        B(cnt)=V;
        cnt=cnt+1;
    end
end



t_i=0.00001;
for t=t_i:t_i:Xmax
    f=sinc(pi/delta*(t-k*delta));
    s_a(i)=sum(s.*f);
    i=i+1;
end;



Листинг 1 программы обработки сообщений (SCADA)

namespace MSmessage
{
    using System;
    using System.Diagnostics;
    using System.Threading;
#if NETSTANDARD1_0
    using System.Reflection;
#endif

    public sealed class MessageHub : IMessageHub
    {
        #region Singleton
        private static readonly MessageHub _instance = new MessageHub();
        static MessageHub() { }
        private MessageHub() { }
        #endregion

        private Action<Type, object> _globalHandler;
        private int _disposed;

        public static MessageHub Instance => _instance;
        public event EventHandler<MessageHubErrorEventArgs> OnError;
        public void RegisterGlobalHandler(Action<Type, object> onMessage)
        {
            EnsureNotNull(onMessage);
            EnsureNotDisposed();

            _globalHandler = onMessage;
        }

        public void Publish<T>(T message)
        {
            var localSubscriptions = Subscriptions.GetTheLatestRevisionOfSubscriptions();
            var msgType = typeof(T);

#if NET_STANDARD
            var msgTypeInfo = msgType.GetTypeInfo();
#endif
            _globalHandler?.Invoke(msgType, message);

                        for (var idx = 0; idx < localSubscriptions.Length; idx++)
            {
                var subscription = localSubscriptions[idx];

#if NET_STANDARD
                if (!subscription.Type.GetTypeInfo().IsAssignableFrom(msgTypeInfo)) { continue; }
#else
                if (!subscription.Type.IsAssignableFrom(msgType)) { continue; }
#endif
                try
                {
                    subscription.Handle(message);
                }
                catch (Exception e)
                {
                    var copy = OnError;
                    copy.Invoke(this, new MessageHubErrorEventArgs(e, subscription.Token));
                }
            }
        }

        public Guid Subscribe<T>(Action<T> action)
        {
            return Subscribe(action, TimeSpan.Zero);
        }

        public Guid Subscribe<T>(Action<T> action, TimeSpan throttleBy)
        {
            EnsureNotNull(action);
            EnsureNotDisposed();

            return Subscriptions.Register(throttleBy, action);
        }

        public void UnSubscribe(Guid token)
        {
            EnsureNotDisposed();
            Subscriptions.UnRegister(token);
        }

        public bool IsSubscribed(Guid token)
        {
            EnsureNotDisposed();
            return Subscriptions.IsRegistered(token);
        }

        public void ClearSubscriptions()
        {
            EnsureNotDisposed();
            Subscriptions.Clear();
        }

        public void Dispose()
        {
            Interlocked.Increment(ref _disposed);
            Subscriptions.Dispose();
        }

        [DebuggerStepThrough]
        private void EnsureNotDisposed()
        {
            if (_disposed == 1) { throw new ObjectDisposedException(GetType().Name); }
        }
        [DebuggerStepThrough]
        private void EnsureNotNull(object obj)
        {
            if (obj == null) { throw new NullReferenceException(nameof(obj)); }
        }
    }
}
namespace MSmessage
{
    using System;
    public interface IMessageHub : IDisposable
    {
        event EventHandler<MessageHubErrorEventArgs> OnError;

        void ClearSubscriptions();
    }
}
namespace MSmessage
{
    using System;
        public MessageHubErrorEventArgs(Exception e, Guid token)
        {
            Exception = e;
            Token = token;
        }

        public Guid Token { get; }
    }
}

namespace MSmessage
{
    using System;
    using System.Diagnostics;

    internal sealed class Subscription
    {
        private const long TicksMultiplier = 1000 * TimeSpan.TicksPerMillisecond;
        private readonly long _throttleByTicks;
        private double? _lastHandleTimestamp;

        internal Subscription(Type type, Guid token, TimeSpan throttleBy, object handler)
        {
            Type = type;
            Token = token;
            Handler = handler;
            _throttleByTicks = throttleBy.Ticks;
        }
        internal void Handle<T>(T message)
        {
            if (!CanHandle()) { return; }

            var handler = Handler as Action<T>;
            handler(message);
        }

        internal bool CanHandle()
        {
            if (_throttleByTicks == 0) { return true; }

            if (_lastHandleTimestamp == null)
            {
                _lastHandleTimestamp = Stopwatch.GetTimestamp();
                return true;
            }

            var now = Stopwatch.GetTimestamp();
            var durationInTicks = (now - _lastHandleTimestamp) / Stopwatch.Frequency * TicksMultiplier;

            if (durationInTicks >= _throttleByTicks)
            {
                _lastHandleTimestamp = now;
                return true;
            }
            return false;
        }
        internal Guid Token { get; }
        internal Type Type { get; }
        private object Handler { get; }
    }
}

namespace MSmessage
{
    using System;
    using System.Collections.Generic;
    using System.Linq;

    internal static class Subscriptions
    {
        private static readonly List<Subscription> AllSubscriptions = new List<Subscription>();
        private static int _subscriptionRevision;

        [ThreadStatic]
        private static int _localSubscriptionRevision;

        [ThreadStatic]
        private static Subscription[] _localSubscriptions;

        internal static Guid Register<T>(TimeSpan throttleBy, Action<T> action)
        {
            var type = typeof(T);
            var key = Guid.NewGuid();
            var subscription = new Subscription(type, key, throttleBy, action);

            lock (AllSubscriptions)
            {
                AllSubscriptions.Add(subscription);
                _subscriptionRevision++;
            }
            return key;
        }

        internal static void UnRegister(Guid token)
        {
            lock (AllSubscriptions)
            {
                var subscription = AllSubscriptions.FirstOrDefault(s => s.Token == token);
                var removed = AllSubscriptions.Remove(subscription);

                if (removed) { _subscriptionRevision++; }
            }
        }
        internal static void Clear()
        {
            lock (AllSubscriptions)
            {
                AllSubscriptions.Clear();
                _subscriptionRevision++;
            }
        }

        internal static Subscription[] GetTheLatestRevisionOfSubscriptions()
        {
            if (_localSubscriptions == null)
            {
                _localSubscriptions = new Subscription[0];
            }
            if (_localSubscriptionRevision == _subscriptionRevision)
            {
                return _localSubscriptions;
            }

            Subscription[] latestSubscriptions;
            lock (AllSubscriptions)
            {
                latestSubscriptions = AllSubscriptions.ToArray();
                _localSubscriptionRevision = _subscriptionRevision;
            }

            _localSubscriptions = latestSubscriptions;

            return latestSubscriptions;
        }

        internal static void Dispose()
        {
            Clear();
        }
    }
}



Листинг 2 программы оцифровки контрольно-измерительных сигналов

//1) Выборка 20 000 элементов из файла
fid = fopen('C:\temp\split\T.txt', 'rb');  if fid == -1
    error('File is not opened');
end
count = 20000;
X= 1:count-1;
B=0;
cnt=1;
while count~=cnt        [V,N] = fread(fid, 1, 'double');
    if N > 0
        B(cnt)=V;
        cnt=cnt+1;
    end
end
fclose(fid);

//2) Подтверждение теоремы Котельникова через интерполяцию
clear all; close all;
N=100;
fd=10; f=1;
Td=1/fd;
X=0:1:N-1;
j=1;
delta=Td;
fd2=10000; Td2=1/fd2;
for iv=0:1:fd2/fd*N
    for i = 1:length(B)
     f(i) = B(i)*mysinc(pi/delta*( iv*Td2-(i-1)*delta) );
     s_a(j)=s_a(j)+f(i);
   end
   j=j+1;
end;
plot(X,B)
figure,
plot(0:1:fd2/fd*N,s_a)

//3) Функция sinc (перереализована, так как стандартная функция sinc в Matlab есть отношение sinc(x)=sin(pi•x)/pi•x, а нам необходима форма sinc(x)=sin(x)/x)
function [otvet]=mysinc(x)
if (x==0) otvet=1;
else
    otvet=sin(x)/x;
end;

-----------------------------------------------------------------------------------------