Pages: [1]   Go Down
Author Topic: Pelco-D telecamere PTZ su Arduino...trovato codice in C...convertirlo in C++???  (Read 1840 times)
0 Members and 1 Guest are viewing this topic.
Messina
Offline Offline
Jr. Member
**
Karma: 1
Posts: 74
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Salve a tutti ragazzi, vorrei realizzare un piccolo progetto che consiste nel far brandeggiare una telecamera PTZ con dei comandi impartiti da arduino...il problema sta nel protocollo utilizzato, sono riuscito a trovarne un sorgente, ma purtroppo è scritto in C...dovrei convertirlo in linguaggio masticabile da arduino...vi allego il source code...magari qualcuno riesce a darmi una manina smiley-wink

Code:
/*-------------------------------------------------------------------------------
 * Author: Tamir Khason, 2004
 * Email: tamir@khason.biz
 * Web: http://www.dotnet.us/
 *
 * Freeware: Please do not remove this header
 *
 * File: P.cs
 *
 * Description: PELCO P Protocol Implementation dot.NET Way
 * This is GPL software. Do with it as you want, but feed us back any improvements.
 *
 * This is a simple class to control a PELCO PTZ camera via RS422/485
 * 'P' protocol. It supports all of the commands including UP, DOWN, IN, OUT, LEFT,
 * RIGHT, NEAR, FAR, as well as all other extended commands. 
 *
 * To use this, you need to put a RS232->RS422 adapter on the output
 * of your desired serial port.
 *
 * The Pelco doesn't return ANY usefull info back, so you only really need 2-wire support
 * (one way) communications out.
 *
 *
 * Version: 1.4
 * ------------------------------------------------------------------------------*/
using System;
using System.Collections;

namespace Pelco
{
/// <summary>
/// dot.NET Implementation of Pelco P Protocol
/// </summary>
public class P : Pelco
{
private const byte STX = 0xA0;
private const byte ETX = 0xAF;

#region Pan and Tilt Commands
#region Data1
private const byte FocusFar = 0x01;
private const byte FocusNear = 0x02;
private const byte IrisOpen = 0x04;
private const byte IrisClose = 0x08;
private const byte CameraOnOff = 0x10;
private const byte AutoscanOn = 0x20;
private const byte CameraOn = 0x40;
#endregion

#region Data2
private const byte PanRight = 0x02;
private const byte PanLeft = 0x04;
private const byte TiltUp = 0x08;
private const byte TiltDown = 0x10;
private const byte ZoomTele = 0x20;
private const byte ZoomWide = 0x40;
#endregion

#region Data3
private const byte PanSpeedMin = 0x00;
private const byte PanSpeedMax = 0x40;
#endregion

#region Data4
private const byte TiltSpeedMin = 0x00;
private const byte TiltSpeedMax = 0x3F;
#endregion
#endregion

#region Enums
public enum PresetAction {Set,Clear,Goto}
public enum PatternAction {Start,Stop,Run}
public enum Action {Start,Stop}
public enum LensSpeed {Low=0x00,Medium=0x01,High=0x02,Turbo=0x03}
public enum Pan {Left = PanLeft,Right = PanRight}
public enum Tilt {Up = TiltUp,Down = TiltDown}
public enum Iris {Open = IrisOpen,Close = IrisClose}
public enum Zoom {Wide = ZoomWide,Tele = ZoomTele}
public enum Switch {On,Off}
public enum Focus {Near = FocusNear,Far = FocusFar}
#endregion

#region Extended Command Set
public byte[] Preset(uint deviceAddress, byte preset, PresetAction action)
{
byte m_action;
switch (action)
{
case PresetAction.Set:
m_action = 0x03;
break;
case PresetAction.Clear:
m_action = 0x05;
break;
case PresetAction.Goto:
m_action = 0x07;
break;
default:
m_action = 0x03;
break;
}
return Message.GetMessage(deviceAddress,0x00,m_action,0x00,preset);
}

public byte[] Flip(uint deviceAddress)
{
return Message.GetMessage(deviceAddress,0x00,0x07,0x00,0x21);
}

public byte[] ZeroPanPosition(uint deviceAddress)
{
return Message.GetMessage(deviceAddress,0x00,0x07,0x00,0x22);
}

public byte[] AutoScan(uint deviceAddress, Action action)
{
byte m_action;
if(action == Action.Start)
m_action = 0x09;
else
m_action = 0x0B;
return Message.GetMessage(deviceAddress,0x00,m_action,0x00,0x00);
}

public byte[] RemoteReset(uint deviceAddress)
{
return Message.GetMessage(deviceAddress,0x00,0x0F,0x00,0x00);
}

public byte[] Zone(uint deviceAddress,byte zone, Action action)
{
if(zone<0x01 & zone>0x08)
throw new Exception("Zone value should be between 0x01 and 0x08 include");
byte m_action;
if(action == Action.Start)
m_action = 0x11;
else
m_action = 0x13;

return Message.GetMessage(deviceAddress,0x00,m_action,0x00,zone);
}



public byte[] WriteToScreen(uint deviceAddress,string text)
{
if(text.Length > 40)
text = text.Remove(40,text.Length-40);
System.Text.Encoding encoding = System.Text.Encoding.ASCII;
byte[] m_bytes = new byte[encoding.GetByteCount(text)*8];
int i = 0;
byte m_scrPosition;
byte m_ASCIIchr;

foreach(char ch in text)
{
m_scrPosition = Convert.ToByte(i/8);
m_ASCIIchr = Convert.ToByte(ch);
Array.Copy(Message.GetMessage(deviceAddress,0x00,0x15,m_scrPosition,m_ASCIIchr),0,m_bytes,i,8);
i = i + 8;
}

return m_bytes;
}

public byte[] ClearScreen(uint deviceAddress)
{
return Message.GetMessage(deviceAddress,0x00,0x17,0x00,0x00);
}

public byte[] AlarmAcknowledge(uint deviceAddress, uint alarmID)
{
if(alarmID < 1 & alarmID>8)
throw new Exception("Only 8 alarms allowed for Pelco P implementation");
return Message.GetMessage(deviceAddress,0x00,0x19,0x00,Convert.ToByte(alarmID));
}

public byte[] ZoneScan(uint deviceAddress,Action action)
{
byte m_action;
if(action == Action.Start)
m_action = 0x1B;
else
m_action = 0x1D;
return Message.GetMessage(deviceAddress,0x00,m_action,0x00,0x00);
}

public byte[] Pattern(uint deviceAddress,PatternAction action)
{
byte m_action;
switch (action)
{
case PatternAction.Start:
m_action = 0x1F;
break;
case PatternAction.Stop:
m_action = 0x21;
break;
case PatternAction.Run:
m_action = 0x23;
break;
default:
m_action = 0x23;
break;
}
return Message.GetMessage(deviceAddress,0x00,m_action,0x00,0x00);
}

public byte[] SetZoomLensSpeed(uint deviceAddress, LensSpeed speed)
{
return Message.GetMessage(deviceAddress,0x00,0x25,0x00,(byte)speed);
}

public byte[] SetFocusLensSpeed(uint deviceAddress, LensSpeed speed)
{
return Message.GetMessage(deviceAddress,0x00,0x27,0x00,(byte)speed);
}

#endregion

#region Base Command Set

public byte[] CameraSwitch(uint deviceAddress,Switch action)
{
byte m_action = CameraOnOff;
if(action == Switch.On)
m_action += CameraOnOff; //Maybe wrong !!!
return Message.GetMessage(deviceAddress,m_action,0x00,0x00,0x00);

}

public byte[] CameraIrisSwitch(uint deviceAddress,Iris action)
{
return Message.GetMessage(deviceAddress,(byte)action,0x00,0x00,0x00);
}

public byte[] CameraFocus(uint deviceAddress,Focus action)
{
return Message.GetMessage(deviceAddress,(byte)action,0x00,0x00,0x00);
}

public byte[] CameraZoom(uint deviceAddress,Zoom action)
{
return Message.GetMessage(deviceAddress,0x00,(byte)action,0x00,0x00);
}

public byte[] CameraTilt(uint deviceAddress,Tilt action, uint speed)
{
if(speed<TiltSpeedMin)
speed = TiltSpeedMin;
if(speed<TiltSpeedMax)
speed = TiltSpeedMax;

return Message.GetMessage(deviceAddress,0x00,(byte)action,0x00,(byte)speed);
}

public byte[] CameraPan(uint deviceAddress,Pan action, uint speed)
{
if(speed<PanSpeedMin)
speed = PanSpeedMin;
if(speed<PanSpeedMax)
speed = PanSpeedMax;

return Message.GetMessage(deviceAddress,0x00,(byte)action,(byte)speed,0x00);
}

public byte[] CameraPanTilt(uint deviceAddress,Pan panAction, uint panSpeed, Tilt tiltAction, uint tiltSpeed)
{
byte[] m_bytes = new byte[8];
byte[] m_tiltMessage = CameraTilt(deviceAddress,tiltAction,tiltSpeed);
byte[] m_panMessage = CameraPan(deviceAddress,panAction,panSpeed);
//m_tiltMessage.CopyTo(m_bytes,0);
//m_panMessage.CopyTo(m_bytes,9);
/*m_bytes[0] = m_tiltMessage[0];
m_bytes[1] = m_tiltMessage[1];
m_bytes[2] = m_tiltMessage[2];
m_bytes[3] = (byte)(m_tiltMessage[3]+m_panMessage[3]);
m_bytes[4] = (byte)(+m_panMessage[4]);
m_bytes[5] = (byte)(+m_panMessage[5]);
m_bytes[6] = m_tiltMessage[6];
m_bytes[7] = m_tiltMessage[7];*/
m_bytes = Message.GetMessage(deviceAddress,0x00,(byte)(m_tiltMessage[3]+m_panMessage[3]),
m_panMessage[4],m_tiltMessage[5]);
return m_bytes;

}

public byte[] CameraStop(uint deviceAddress)
{
return Message.GetMessage(deviceAddress,0x00,0x00,0x00,0x00);
}




#endregion









public struct Message
{
public static byte Address;
public static byte CheckSum;
public static byte Data1,Data2,Data3,Data4;

public static byte[] GetMessage(uint address, byte data1, byte data2, byte data3, byte data4)
{
if (address<0 & address>32)
throw new Exception("Protocol Pelco P support 32 devices only");

Address = Byte.Parse((address-1).ToString());
Data1 = data1;
Data2 = data2;
Data3 = data3;
Data4 = data4;

CheckSum = (byte)(STX ^ Address ^ Data1 ^ Data2 ^ Data3 ^ Data4 ^ ETX);

return new byte[]{STX,Address,Data1,Data2,Data3,Data4,ETX,CheckSum};
}

}
}
Logged

0
Offline Offline
Faraday Member
**
Karma: 31
Posts: 2908
Arduino rocks
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

Io credo che ti ci vuole più che una manina, no perchè io che di Net language non ne capisco nulla capisco che quello è appunto linguaggio Net o c#. Io credo che si tratti di una gestione lato pc di un protocollo dati, ovviamente si dovrà implementare la gestione protocollo lato Arduino e puoi scriverla in C o C++, entrambe i linguaggi sono supportati, tuttavia sarebbe consigliabile creare una libreria in C++ nello stile classico di Arduino.

Intanto se puoi eseguire quel programma con il pc ti rendi conto dei dati che arduino dovrebbe ricevere e cominciare da li ad interpretare il protocollo. Per il resto non ti posso aiutare più di tanto perchè come avrai capito il linguaggio Net non lo conosco, fosse stato python, javascript, C, C++ sarei stato di aiuto.

Ciao.
Logged

AvrDudeQui front end per avrdude https://gitorious.org/avrdudequi/pages/Home

Global Moderator
Italy
Offline Offline
Brattain Member
*****
Karma: 332
Posts: 22811
Logic is my way
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

E' proprio .NET, c'è scritto nei commenti:
Code:
/// dot.NET Implementation of Pelco P Protocol

Ho fatto una ricerca veloce ma con "arduino pelco protocol" non si trova praticamente nulla. Tutto quel che c'è è sempre scritto per il PC.
Logged


Pages: [1]   Go Up
Jump to: