static Boolean TestKnownEnc(Aes aes, Byte[] Key, Byte[] IV, Byte[] Plain, Byte[] Cipher) { Byte[] CipherCalculated; Console.WriteLine("Encrypting the following bytes:"); PrintByteArray(Plain); Console.WriteLine("With the following Key:"); PrintByteArray(Key); Console.WriteLine("and IV:"); PrintByteArray(IV); Console.WriteLine("Expecting this ciphertext:"); PrintByteArray(Cipher); ICryptoTransform sse = aes.CreateEncryptor(Key, IV); MemoryStream ms = new MemoryStream(); CryptoStream cs = new CryptoStream(ms, sse, CryptoStreamMode.Write); cs.Write(Plain,0,Plain.Length); cs.FlushFinalBlock(); CipherCalculated = ms.ToArray(); cs.Close(); Console.WriteLine("Computed this cyphertext:"); PrintByteArray(CipherCalculated); if (!Compare(Cipher, CipherCalculated)) { Console.WriteLine("ERROR: result is different from the expected"); return false; } Console.WriteLine("OK"); return true; }
public Byte[] SignHash (Byte[] rgbHash, string str) { Contract.Requires(rgbHash != null); Contract.Requires(rgbHash.Length == 20); Contract.Requires(rgbHash.Length == 16); return default(Byte[]); }
public static Byte[] bin2CArray(Byte[] inputData, UInt32 memberSizeInBytes) { StringBuilder cArraySB; UInt32 sizeSB = (((UInt32)inputData.Length)/memberSizeInBytes +1) * (memberSizeInBytes*2 + 4) + 30; cArraySB = new StringBuilder((Int32)sizeSB); switch(memberSizeInBytes) { case 1: bin2charArray(inputData,cArraySB); break; case 2: break; case 4: bin2uintArray(inputData,cArraySB); break; case 8: break; default: break; } return (new ASCIIEncoding()).GetBytes(cArraySB.ToString()); }
public static bool SendFileToPrinter( string szPrinterName, string szFileName ) { // Open the file. FileStream fs = new FileStream(szFileName, FileMode.Open); // Create a BinaryReader on the file. BinaryReader br = new BinaryReader(fs); // Dim an array of bytes big enough to hold the file's contents. Byte []bytes = new Byte[fs.Length]; bool bSuccess = false; // Your unmanaged pointer. IntPtr pUnmanagedBytes = new IntPtr(0); int nLength; nLength = Convert.ToInt32(fs.Length); // Read the contents of the file into the array. bytes = br.ReadBytes( nLength ); // Allocate some unmanaged memory for those bytes. pUnmanagedBytes = Marshal.AllocCoTaskMem(nLength); // Copy the managed byte array into the unmanaged array. Marshal.Copy(bytes, 0, pUnmanagedBytes, nLength); // Send the unmanaged bytes to the printer. bSuccess = SendBytesToPrinter(szPrinterName, pUnmanagedBytes, nLength); // Free the unmanaged memory that you allocated earlier. Marshal.FreeCoTaskMem(pUnmanagedBytes); return bSuccess; }
private static void SendFile() { // Создаем файловый поток и переводим его в байты Byte[] bytes = new Byte[fs.Length]; fs.Read(bytes, 0, bytes.Length); Console.WriteLine("Отправка файла размером " + fs.Length + " байт"); try { // Отправляем файл sender.Send(bytes, bytes.Length, endPoint); } catch (Exception eR) { Console.WriteLine(eR.ToString()); } finally { // Закрываем соединение и очищаем поток fs.Close(); sender.Close(); } Console.WriteLine("Файл успешно отправлен."); Console.Read(); }
/// <summary> /// 客户端 /// </summary> /// <param name="ip"></param> /// <param name="port"></param> /// <param name="message"></param> static void Client(string ip, int port, string message) { try { //1.发送数据 TcpClient client = new TcpClient(ip, port); IPEndPoint ipendpoint = client.Client.RemoteEndPoint as IPEndPoint; NetworkStream stream = client.GetStream(); byte[] messages = Encoding.Default.GetBytes(message); stream.Write(messages, 0, messages.Length); Console.WriteLine("{0:HH:mm:ss}->发送数据(to {1}):{2}", DateTime.Now, ip, message); //2.接收状态,长度<1024字节 byte[] bytes = new Byte[1024]; string data = string.Empty; int length = stream.Read(bytes, 0, bytes.Length); if (length > 0) { data = Encoding.Default.GetString(bytes, 0, length); Console.WriteLine("{0:HH:mm:ss}->接收数据(from {1}:{2}):{3}", DateTime.Now, ipendpoint.Address, ipendpoint.Port, data); } //3.关闭对象 stream.Close(); client.Close(); } catch (Exception ex) { Console.WriteLine("{0:HH:mm:ss}->{1}", DateTime.Now, ex.Message); } Console.ReadKey(); }
static void Main(string[] args) { Log.Info("WorldServer", "Starting..."); if (!EasyServer.InitLog("World", "Configs/WorldLog.conf") || !EasyServer.InitConfig("Configs/World.xml", "World")) return; Port = EasyServer.GetConfValue<int>("World", "Address", "Port"); IP1 = EasyServer.GetConfValue<Byte>("World", "Address", "IP1"); IP2 = EasyServer.GetConfValue<Byte>("World", "Address", "IP2"); IP3 = EasyServer.GetConfValue<Byte>("World", "Address", "IP3"); IP4 = EasyServer.GetConfValue<Byte>("World", "Address", "IP4"); if (!EasyServer.Listen<TcpServer>(Port, "ClientServer")) return; Database.Connection.connectionString = EasyServer.GetConfValue<String>("World", "Database", "ConnectionString"); FileMgr = new FileManager(); Password = EasyServer.GetConfValue<string>("World", "Lobby", "Password"); WorldName = EasyServer.GetConfValue<string>("World", "ClientServer", "Name"); ID = EasyServer.GetConfValue<Byte>("World", "ClientServer", "Id"); Lobby = new Lobby.Client(EasyServer.GetConfValue<String>("World", "Lobby", "Ip"), EasyServer.GetConfValue<int>("World", "Lobby", "Port")); districtsListener = new Districts.Listener(EasyServer.GetConfValue<String>("World", "Districts", "Ip"), EasyServer.GetConfValue<int>("World", "Districts", "Port")); clients.Clear(); Log.Enter(); Console.WriteLine("For available console commands, type /commands"); Log.Enter(); bool done = false; while (!done) { string command; command = Console.ReadLine(); ProccessCommand(command); } EasyServer.StartConsole(); }
protected StreamContent(Byte[] contentBytes) { Debug.Assert(contentBytes != null); ContentBytes = contentBytes; ContentLength = (UInt32)contentBytes.Length; }
public static int IntPtrCopy(IntPtr source, Stream dest, int length) { var buffer = new Byte[length]; Marshal.Copy(source, buffer, 0, length); dest.Write(buffer, 0, length); return length; }
static void Main(string[] args) { //AsyncReadOneFile(); //AsyncReadMultiplyFiles(); FileStream fs = new FileStream(@"../../Program.cs", FileMode.Open, FileAccess.Read, FileShare.Read, 1024, FileOptions.Asynchronous); Byte[] data = new Byte[100]; IAsyncResult ar = fs.BeginRead(data, 0, data.Length, null, null); while (!ar.IsCompleted) { Console.WriteLine("Операция не завершена, ожидайте..."); Thread.Sleep(10); } Int32 bytesRead = fs.EndRead(ar); fs.Close(); Console.WriteLine("Количество считаных байт = {0}", bytesRead); Console.WriteLine(Encoding.UTF8.GetString(data).Remove(0, 1)); }
public Message Decode(Byte[] data) { Byte[] buffer = new Byte[14]; if (data.Length >= 14) Buffer.BlockCopy(data, 0, buffer, 0, 14); else Buffer.BlockCopy(data, 0, buffer, 0, data.Length); MessageHeader header = analyseHead(buffer); Message msg = new Message(); msg.header = header; Byte[] payload; if (header != null) { payload = new Byte[data.Length - header.PayloadDataStartIndex]; Buffer.BlockCopy(data, header.PayloadDataStartIndex, payload, 0, payload.Length); if (header.MASK == charOne) { for (int i = 0; i < payload.Length; i++) { payload[i] = (Byte)(payload[i] ^ header.Maskey[i % 4]); } } } else { msg.Data = Encoding.UTF8.GetString(data); return msg; } if (header.Opcode == OperType.Text) msg.Data = Encoding.UTF8.GetString(payload); return msg; }
public GGuess() { _UserNum = (0); _AllJinbi = (0); _ResultUserNum = (0); _Status = (0); }
public static Byte[] Encrypt(Byte[] data, Byte[] Key) { if (data.Length == 0) { return data; } return ToByteArray(Encrypt(ToUInt32Array(data, true), ToUInt32Array(Key, false)), false); }
private void chatServer() { Boolean isListen = true; while (isListen) { Byte[] bytesFromClient = new Byte[2097152]; int len = 0; try { len = _userSocket.Receive(bytesFromClient); byte[] receiveByte = new byte[len]; receiveByte = bytesFromClient; Message.Message msg = Message.MessageHandle.deserialize(receiveByte); _clientRoom.broadcast(msg); } catch (Exception e) { isListen = false; _clientRoom.removeUser(_userName); _userSocket.Close(); _userSocket = null; Debug.WriteLine(e); Debug.WriteLine(_userName + "退出聊天"); LogService.LogError(e.ToString()); } } }
/// <summary> /// Print a nice visual of the Buffer starting at offset. /// </summary> /// <param name="buffer">Buffer.</param> /// <param name="Offset">Offset.</param> public static void PrintHEX(Byte[] buffer, int Offset = 0) { Console.WriteLine(" 0 1 2 3 4 5 6 7 8 9 A B C D E F | Text "); Console.WriteLine("------------------------------------------------|---------"); int count = 0, cur = 0; String left = "", right = ""; foreach (byte b in buffer) { if (cur >= Offset) { if (count >= 16) { Console.WriteLine("{0}| {1}", left, right); left = ""; right = ""; count = 0; } left += String.Format("{0:x2} ", b); if (b >= 32 && b <= 255) right += (char)b; else right += "."; count++; } else cur++; } if (count > 0) Console.WriteLine("{0}| {1}", left.PadRight(48), right); }
public byte[] StreamToByte(System.IO.Stream Stream) { Int32 length = Stream.Length > Int32.MaxValue ? Int32.MaxValue : Convert.ToInt32(Stream.Length); Byte[] buffer = new Byte[length]; Stream.Read(buffer, 0, length); return buffer; }
public District(DistrictTypes type, Byte id, LanguageCodes langCode = LanguageCodes.EN) { _type = type; _lang = langCode; Type = (Byte)((Byte)type + (Byte)langCode); Id = id; }
/// <summary> /// Checks if the bytes contains invalid UTF-8 bytes /// </summary> public static Boolean ContainsInvalidUTF8Bytes(Byte[] bytes) { Int32 bits = 0; Int32 i = 0, c = 0, b = 0; Int32 length = bytes.Length; for (i = 0; i < length; i++) { c = bytes[i]; if (c > 128) { if ((c >= 254)) return true; else if (c >= 252) bits = 6; else if (c >= 248) bits = 5; else if (c >= 240) bits = 4; else if (c >= 224) bits = 3; else if (c >= 192) bits = 2; else return true; if ((i + bits) > length) return true; while (bits > 1) { i++; b = bytes[i]; if (b < 128 || b > 191) return true; bits--; } } } return false; }
/// <summary> /// AES解密(无向量) /// </summary> /// <param name="encryptedBytes">被加密的明文</param> /// <param name="key">密钥</param> /// <returns>明文</returns> public static string AESDecryptWithoutVector(String Data, String Key) { Byte[] encryptedBytes = Convert.FromBase64String(Data); Byte[] bKey = new Byte[32]; Array.Copy(Encoding.UTF8.GetBytes(Key.PadRight(bKey.Length)), bKey, bKey.Length); MemoryStream mStream = new MemoryStream(encryptedBytes); //mStream.Write( encryptedBytes, 0, encryptedBytes.Length ); //mStream.Seek( 0, SeekOrigin.Begin ); RijndaelManaged aes = new RijndaelManaged(); aes.Mode = CipherMode.ECB; aes.Padding = PaddingMode.PKCS7; aes.KeySize = 128; aes.Key = bKey; //aes.IV = _iV; CryptoStream cryptoStream = new CryptoStream(mStream, aes.CreateDecryptor(), CryptoStreamMode.Read); try { byte[] tmp = new byte[encryptedBytes.Length + 32]; int len = cryptoStream.Read(tmp, 0, encryptedBytes.Length + 32); byte[] ret = new byte[len]; Array.Copy(tmp, 0, ret, 0, len); return Encoding.UTF8.GetString(ret); } finally { cryptoStream.Close(); mStream.Close(); aes.Clear(); } }
public static string[] Search(String[] token, String txt, out Byte distance) { if (txt.Length > 0) { Byte bestKey = 255; SortedDictionary<Byte, List<string>> matches = new SortedDictionary<byte, List<string>>(); Docking.Tools.ITextMetric tm = new Docking.Tools.Levenshtein(50); foreach(string s in token) { Byte d = tm.distance(txt, s); if (d <= bestKey) // ignore worse matches as previously found { bestKey = d; List<string> values; if (!matches.TryGetValue(d, out values)) { values = new List<string>(); matches.Add(d, values); } if (!values.Contains(s)) values.Add(s); } } if (matches.Count > 0) { List<string> result = matches[bestKey]; distance = bestKey; return result.ToArray(); } } distance = 0; return null; }
public UserLogonInstruction(string user, Byte connection) : base(3, true, user) { this.user = user + '\0'; this.connection = connection; userSent = true; length += clientName.Length + 1; }
void BaseInit() { _state.Init(); _previousByte = 0; for (UInt32 i = 0; i < Base.kNumRepDistances; i++) _repDistances[i] = 0; }
/// <summary> /// Takes in a byte array so it is possible to get the sequence number and packet data /// </summary> /// <param name="packetInfo"></param> public void convertToPacket(byte[] packetInfo) { Byte[] sequenceNumber = new Byte[4]; sequenceNumber[0] = packetInfo[0]; sequenceNumber[1] = packetInfo[1]; sequenceNumber[2] = packetInfo[2]; sequenceNumber[3] = packetInfo[3]; // convert the sequence number to an int //string seqStr = BitConverter.ToString(sequenceNumber, 0); //packetNum = int.Parse(seqStr); packetNum = BitConverter.ToInt32(sequenceNumber, 0); // if start packet if (packetNum == 0) { isStartPacket = true; // the rest of the data is just the number of packets // the number is grabed and converted to int numOfPackets = BitConverter.ToInt32(packetInfo, 4); // array is resized to be the number of pieces of data } else { byte[] tempData = new byte[packetInfo.Length - 4]; // convert the rest of the data to ascii text for (int i = 4; i < packetInfo.Length; i++) { tempData[i - 4] = packetInfo[i]; } data = tempData; } }
private void StartListen2() { //Create an instance of TcpListener to listen for TCP connection. var tcpListener = new TcpListener(SampleTcpPort); try { while (true) { tcpListener.Start(); //Program blocks on Accept() until a client connects. Socket soTcp = tcpListener.AcceptSocket(); Console.Message = ("SampleClient is connected through TCP."); OnChanged(EventArgs.Empty); var received = new Byte[512]; soTcp.Receive(received, received.Length, 0); String dataReceived = System.Text.Encoding.ASCII.GetString(received); Console.Message=(dataReceived); String returningString = "The Server got your message through TCP: " + dataReceived; OnChanged(EventArgs.Empty); Byte[] returningByte = System.Text.Encoding.ASCII.GetBytes (returningString.ToCharArray()); //Returning a confirmation string back to the client. soTcp.Send(returningByte, returningByte.Length, 0); } } catch (SocketException se) { Console.Message = ("A Socket Exception has occurred!" + se); OnChanged(EventArgs.Empty); } }
public void Recieve() { Byte[] data = new Byte[256]; NetworkStream stream = client.GetStream(); String responseData = String.Empty; Int32 bytes = stream.Read(data, 0, data.Length); }
protected void EnviaFicheiro_Click(object sender, EventArgs e) { int tamanho = 0; byte[] vector = null; if (!FileUploadImagem.HasFile) { lbStatus.Text = "Não existe nenhum ficheiro selecionado"; return; } string nomeFicheiro = FileUploadImagem.PostedFile.FileName; string ext = nomeFicheiro.Substring(nomeFicheiro.LastIndexOf(".")); ext.ToLower(); string imgTipo = FileUploadImagem.PostedFile.ContentType; if (ext != ".jpg" && ext != ".bmp" && ext != ".gif" && ext != ".jpeg" && ext != ".png" && ext != ".tiff") lbStatus.Text = "Só são suportados os formatos: jpg/jpeg, bmp, gif, png, tiff"; tamanho = Int32.Parse(FileUploadImagem.PostedFile.ContentLength.ToString()); vector = new Byte[tamanho]; FileUploadImagem.PostedFile.InputStream.Read(vector, 0, tamanho); if (GuardaImagem2(TextBoxTitulo.Text.Trim(), vector, tamanho, imgTipo)) lbStatus.Text = "Imagem enviada."; else lbStatus.Text = "Erro ao enviar a imagem..."; }
private string GetResponse(string apiVerb) { TcpClient tcpClient = new TcpClient("127.0.0.1", port); NetworkStream tcpStream = tcpClient.GetStream(); Byte[] request = Encoding.ASCII.GetBytes(apiVerb); tcpStream.Write(request, 0, request.Length); Byte[] responseBuffer = new Byte[4096]; string response = string.Empty; do { int bytesRead = tcpStream.Read(responseBuffer, 0, responseBuffer.Length); response = response + Encoding.ASCII.GetString(responseBuffer, 0, bytesRead); } while (tcpStream.DataAvailable); if (LogEvent != null) { LogEventArgs args = new LogEventArgs(); args.DateTime = DateTime.Now; args.Request = apiVerb; args.Response = response; LogEvent(this, args); } tcpClient.Close(); return response; }
public GroupFoundEventArgs (Byte connection, UInt16 start, UInt16 end, Byte[] uuid) { this.connection = connection; this.start = start; this.end = end; this.uuid = uuid; }
public static ResponseBuilder Connect(RequestBuilder request) { ResponseBuilder response = new ResponseBuilder(); try { Socket s = Connect(request.CurrentURL.Host, request.CurrentURL.Port); if (s == null) throw new Exception("Connection failed"); Byte[] bytesSent = Encoding.UTF8.GetBytes(request.ToString()); Byte[] bytesReceived = new Byte[request.ToString().Length]; // Send request to the server. s.Send(bytesSent, bytesSent.Length, 0); int bytes = 0; do { // Receive response to the server. bytes = s.Receive(bytesReceived, bytesReceived.Length, 0); response.Append(Encoding.UTF8.GetString(bytesReceived, 0, bytes)); } while (bytes > 0); } catch (Exception ex) { response.Clear(); response.AppendLine(ex.Message); response.AppendLine(ex.StackTrace); } return response; }
public static void SendFileInfo() { // Получаем тип и расширение файла fileDet.FILETYPE = fs.Name.Substring((int)fs.Name.Length - 3, 3); // Получаем длину файла fileDet.FILESIZE = fs.Length; XmlSerializer fileSerializer = new XmlSerializer(typeof(FileDetails)); MemoryStream stream = new MemoryStream(); // Сериализуем объект fileSerializer.Serialize(stream, fileDet); // Считываем поток в байты stream.Position = 0; Byte[] bytes = new Byte[stream.Length]; stream.Read(bytes, 0, Convert.ToInt32(stream.Length)); Console.WriteLine("Отправка деталей файла..."); // Отправляем информацию о файле sender.Send(bytes, bytes.Length, endPoint); stream.Close(); }
/* * * static uavcan_message_descriptor_s uavcan_equipment_hardpoint_Status_descriptor = { * UAVCAN_EQUIPMENT_HARDPOINT_STATUS_DT_SIG, * UAVCAN_EQUIPMENT_HARDPOINT_STATUS_DT_ID, * CanardTransferTypeBroadcast, * sizeof(uavcan_equipment_hardpoint_Status), * UAVCAN_EQUIPMENT_HARDPOINT_STATUS_MAX_PACK_SIZE, * encode_func, * decode_func, * null * }; */ static void encode_uavcan_equipment_hardpoint_Status(uavcan_equipment_hardpoint_Status msg, uavcan_serializer_chunk_cb_ptr_t chunk_cb, object ctx) { uint8_t[] buffer = new uint8_t[8]; _encode_uavcan_equipment_hardpoint_Status(buffer, msg, chunk_cb, ctx, true); }
//WRITE8_MEMBER( namco_53xx_device::P_w ) public void P_w(address_space space, offs_t offset, u8 data, u8 mem_mask = 0xff) { m_p.op(space, 0, data); }
private static float ToSignedDistance(TLeafData value) { return((value / (float)TLeafData.MaxValue) * 2f - 1f); }
private void OnOwnerChanged(UInt8 owner) { controlPointAreaRenderer.material.color = controlPointAreaColors[owner]; }
public void SetOwner(UInt8 owner) { Owner = owner; onOwnerChanged?.Invoke(Owner); }
protected abstract bool Read_Byte(ref SerializedType ioData);
/* ** This function returns a pointer to a nul-terminated string in memory ** obtained from sqlite3DbMalloc(). If sqlite3.vdbeExecCnt is 1, then the ** string contains a copy of zRawSql but with host parameters expanded to ** their current bindings. Or, if sqlite3.vdbeExecCnt is greater than 1, ** then the returned string holds a copy of zRawSql with "-- " prepended ** to each line of text. ** ** The calling function is responsible for making sure the memory returned ** is eventually freed. ** ** ALGORITHM: Scan the input string looking for host parameters in any of ** these forms: ?, ?N, $A, @A, :A. Take care to avoid text within ** string literals, quoted identifier names, and comments. For text forms, ** the host parameter index is found by scanning the perpared ** statement for the corresponding OP_Variable opcode. Once the host ** parameter index is known, locate the value in p->aVar[]. Then render ** the value as a literal in place of the host parameter name. */ static string sqlite3VdbeExpandSql( Vdbe p, /* The prepared statement being evaluated */ string zRawSql /* Raw text of the SQL statement */ ) { sqlite3 db; /* The database connection */ int idx = 0; /* Index of a host parameter */ int nextIndex = 1; /* Index of next ? host parameter */ int n; /* Length of a token prefix */ int nToken = 0; /* Length of the parameter token */ int i; /* Loop counter */ Mem pVar; /* Value of a host parameter */ StrAccum _out = new StrAccum(1000); /* Accumulate the _output here */ //StringBuilder zBase = new StringBuilder( 100 ); /* Initial working space */ int izRawSql = 0; db = p.db; sqlite3StrAccumInit(_out, null, 100, db.aLimit[SQLITE_LIMIT_LENGTH]); _out.db = db; if (db.vdbeExecCnt > 1) { while (izRawSql < zRawSql.Length) { //string zStart = zRawSql; while (zRawSql[izRawSql++] != '\n' && izRawSql < zRawSql.Length) { ; } sqlite3StrAccumAppend(_out, "-- ", 3); sqlite3StrAccumAppend(_out, zRawSql, (int)izRawSql);//zRawSql - zStart ); } } else { while (izRawSql < zRawSql.Length) { n = findNextHostParameter(zRawSql, izRawSql, ref nToken); Debug.Assert(n > 0); sqlite3StrAccumAppend(_out, zRawSql.Substring(izRawSql, n), n); izRawSql += n; Debug.Assert(izRawSql < zRawSql.Length || nToken == 0); if (nToken == 0) { break; } if (zRawSql[izRawSql] == '?') { if (nToken > 1) { Debug.Assert(sqlite3Isdigit(zRawSql[izRawSql + 1])); sqlite3GetInt32(zRawSql, izRawSql + 1, ref idx); } else { idx = nextIndex; } } else { Debug.Assert(zRawSql[izRawSql] == ':' || zRawSql[izRawSql] == '$' || zRawSql[izRawSql] == '@'); testcase(zRawSql[izRawSql] == ':'); testcase(zRawSql[izRawSql] == '$'); testcase(zRawSql[izRawSql] == '@'); idx = sqlite3VdbeParameterIndex(p, zRawSql.Substring(izRawSql, nToken), nToken); Debug.Assert(idx > 0); } izRawSql += nToken; nextIndex = idx + 1; Debug.Assert(idx > 0 && idx <= p.nVar); pVar = p.aVar[idx - 1]; if ((pVar.flags & MEM_Null) != 0) { sqlite3StrAccumAppend(_out, "NULL", 4); } else if ((pVar.flags & MEM_Int) != 0) { sqlite3XPrintf(_out, "%lld", pVar.u.i); } else if ((pVar.flags & MEM_Real) != 0) { sqlite3XPrintf(_out, "%!.15g", pVar.r); } else if ((pVar.flags & MEM_Str) != 0) { #if !SQLITE_OMIT_UTF16 u8 enc = ENC(db); if (enc != SQLITE_UTF8) { Mem utf8; memset(&utf8, 0, sizeof(utf8)); utf8.db = db; sqlite3VdbeMemSetStr(&utf8, pVar.z, pVar.n, enc, SQLITE_STATIC); sqlite3VdbeChangeEncoding(&utf8, SQLITE_UTF8); sqlite3XPrintf(_out, "'%.*q'", utf8.n, utf8.z); sqlite3VdbeMemRelease(&utf8); } else #endif { sqlite3XPrintf(_out, "'%.*q'", pVar.n, pVar.z); } } /*else if ( ( pVar.flags & MEM_Zero ) != 0 ) * { * sqlite3XPrintf( _out, "zeroblob(%d)", pVar.u.nZero ); * } */ else { Debug.Assert((pVar.flags & MEM_Blob) != 0); sqlite3StrAccumAppend(_out, "x'", 2); for (i = 0; i < pVar.n; i++) { sqlite3XPrintf(_out, "%02x", pVar.zBLOB[i] & 0xff); } sqlite3StrAccumAppend(_out, "'", 1); } } } return(sqlite3StrAccumFinish(_out)); }
partial void OnShiftIdChanging(System.Byte value);
public virtual void Begin(bool invert = false, uint8_t contrast = 128, uint8_t Vpp = 0) { }
/* * * static uavcan_message_descriptor_s uavcan_protocol_AccessCommandShell_req_descriptor = { * UAVCAN_PROTOCOL_ACCESSCOMMANDSHELL_REQ_DT_SIG, * UAVCAN_PROTOCOL_ACCESSCOMMANDSHELL_REQ_DT_ID, * * CanardTransferTypeRequest, * * sizeof(uavcan_protocol_AccessCommandShell_req), * UAVCAN_PROTOCOL_ACCESSCOMMANDSHELL_REQ_MAX_PACK_SIZE, * encode_func, * decode_func, * * &uavcan_protocol_AccessCommandShell_res_descriptor * * }; */ static void encode_uavcan_protocol_AccessCommandShell_req(uavcan_protocol_AccessCommandShell_req msg, uavcan_serializer_chunk_cb_ptr_t chunk_cb, object ctx) { uint8_t[] buffer = new uint8_t[8]; _encode_uavcan_protocol_AccessCommandShell_req(buffer, msg, chunk_cb, ctx, true); }
internal static string InvalidByteLengthDetected(System.Byte length) { return(Keys.GetString(Keys.InvalidByteLengthDetected, new object[] { length })); }
public ColorRGB(QuantumType red, QuantumType green, QuantumType blue) : base(new MagickColor(red, green, blue)) { }
//! telegraph method : Decode public override Int32 Decode(ref Queue <System.Byte> InputQueue, ref Boolean tRequestDrop) { //! check input queue if ((null == InputQueue) || (null == m_Command) || (0 == InputQueue.Count)) { return(0); } //! frame address System.Byte Command = 0; System.Byte Address = 0; UInt16 CheckSUM = 0xFFFF; UInt16 DataLength = 0; System.Byte[] Datas = null; tRequestDrop = false; //! check the frame using (Queue <Byte> .Enumerator qEnumerator = InputQueue.GetEnumerator()) { if (!qEnumerator.MoveNext()) { qEnumerator.Dispose(); return(0); } //! check frame head if (0xA5 != qEnumerator.Current) { tRequestDrop = true; qEnumerator.Dispose(); return(0); } Byte[] tLength = new Byte[2]; //! get frame destination address if (!qEnumerator.MoveNext()) { qEnumerator.Dispose(); return(0); } else { tLength[0] = qEnumerator.Current; Get_CRC(ref CheckSUM, qEnumerator.Current); } //! get data length if (!qEnumerator.MoveNext()) { qEnumerator.Dispose(); return(0); } else { tLength[1] = qEnumerator.Current; Get_CRC(ref CheckSUM, qEnumerator.Current); DataLength = BitConverter.ToUInt16(tLength, 0); if (0 == DataLength) { qEnumerator.Dispose(); return(0); } DataLength--; Datas = new Byte[DataLength]; } //! get frame command if (!qEnumerator.MoveNext()) { qEnumerator.Dispose(); return(0); } else { Address = qEnumerator.Current; Get_CRC(ref CheckSUM, qEnumerator.Current); if (m_Command.AddressValue != Address) { //! this frame not belong to this telegraph tRequestDrop = true; qEnumerator.Dispose(); return(0); } } //! get frame command if (!qEnumerator.MoveNext()) { qEnumerator.Dispose(); return(0); } else { Command = qEnumerator.Current; Get_CRC(ref CheckSUM, qEnumerator.Current); if ((m_Command.Command != Command) && (0xAC != Command)) { //! this frame not belong to this telegraph tRequestDrop = true; qEnumerator.Dispose(); return(0); } } //! get data for (System.Int32 n = 0; n < DataLength; n++) { //! get frame data length if (!qEnumerator.MoveNext()) { qEnumerator.Dispose(); return(0); } else { Datas[n] = qEnumerator.Current; Get_CRC(ref CheckSUM, qEnumerator.Current); } } Byte[] tCheckSumBuffer = new Byte[2]; //! get check sum Low Byte if (!qEnumerator.MoveNext()) { qEnumerator.Dispose(); return(0); } else { tCheckSumBuffer[0] = qEnumerator.Current; } //! get check sum High Byte if (!qEnumerator.MoveNext()) { qEnumerator.Dispose(); return(0); } else { tCheckSumBuffer[1] = qEnumerator.Current; if (CheckSUM != BitConverter.ToUInt16(tCheckSumBuffer, 0)) { tRequestDrop = true; qEnumerator.Dispose(); return(0); } } /* * //! check frame tail * if ((!qEnumerator.MoveNext()) || (0x55 != qEnumerator.Current)) * { * qEnumerator.Dispose(); * return 0; * } */ if (null != m_Timer) { lock (m_Timer) { try { if (null != m_Timer) { //! start timer m_Timer.Stop(); m_Timer.Enabled = false; m_Timer.Dispose(); m_Timer = null; } } catch (Exception) { } } } } //! decoding success! now, we get all data from queue and create a report ESCommand tempCommand = new ESCommandReadBlock(Datas); //!< create a command //! copy command properies from source command m_Command tempCommand.AddressValue = m_Command.AddressValue; tempCommand.Command = Command; tempCommand.AddressValue = Address; tempCommand.Description = m_Command.Description; tempCommand.ID = m_Command.ID; tempCommand.ResponseMode = m_Command.ResponseMode; tempCommand.TimeOut = m_Command.TimeOut; m_Command = tempCommand; //! raising event OnDecoderSuccess(tempCommand); //! return decode size return(7 + DataLength); }
protected abstract void Write_Byte(ref SerializedType ioData);
static void encode_org_cubepilot_uwb_Node(org_cubepilot_uwb_Node msg, uavcan_serializer_chunk_cb_ptr_t chunk_cb, object ctx) { uint8_t[] buffer = new uint8_t[8]; _encode_org_cubepilot_uwb_Node(buffer, msg, chunk_cb, ctx, true); }
static void encode_uavcan_protocol_debug_LogLevel(uavcan_protocol_debug_LogLevel msg, uavcan_serializer_chunk_cb_ptr_t chunk_cb, object ctx) { uint8_t[] buffer = new uint8_t[8]; _encode_uavcan_protocol_debug_LogLevel(buffer, msg, chunk_cb, ctx, true); }
public void Serialize(string inKey, ref SerializedType ioData, SerializedType inDefault, FieldOptions inOptions = FieldOptions.None) { DoSerialize <SerializedType>(inKey, ref ioData, inDefault, inOptions, Read_Byte, Write_Byte); }
static void encode_uavcan_protocol_file_Error(uavcan_protocol_file_Error msg, dronecan_serializer_chunk_cb_ptr_t chunk_cb, object ctx) { uint8_t[] buffer = new uint8_t[8]; _encode_uavcan_protocol_file_Error(buffer, msg, chunk_cb, ctx, true); }
private bool process_message() { Console.WriteLine("packet: " + gsof_msg.packettype.ToString("X") + " len: " + gsof_msg.length + " status: " + gsof_msg.status); if (gsof_msg.packettype == 0x57) // RAWDATA { uint8_t record_type = gsof_msg.data[0]; uint8_t page_total = (byte)(gsof_msg.data[1] & 0xf); uint8_t page_number = (byte)((gsof_msg.data[1] >> 4) & 0xf); uint8_t reply_number = (byte)gsof_msg.data[2]; uint8_t recordintflags = gsof_msg.data[3]; bool consise = (recordintflags & 0x1) > 0; Console.WriteLine(DateTime.Now.Second + " record type: " + record_type + " page_no " + page_number + "/" + page_total + " consise " + consise); if (record_type == 7) { double p40 = Math.Pow(2, 40); double p39 = Math.Pow(2, 39); double p11 = Math.Pow(2, 11); double p12 = Math.Pow(2, 12); double p14 = Math.Pow(2, 14); double p21 = Math.Pow(2, 21); double p26 = Math.Pow(2, 26); double p17 = Math.Pow(2, 17); double p4 = Math.Pow(2, 4); var test2 = (rt27_7_29)gsof_msg.data.ByteArrayToStructureBigEndian <rt27_7_29>(4); long lat = byte2long(test2.Lat); long lng = byte2long(test2.Lng); Console.WriteLine("{0} {1} {2} {3} {4} {5} ", lat / p40, lng / p39, test2.Alt / p12, (test2.veln / p21), (test2.vele / p21), (test2.velu / p21), test2.rx_clock_offset / p26, test2.rx_clock_drift / p17, test2.hdop / p4); } else if (record_type == 1) { var test2 = (rt27_1_11)gsof_msg.data.ByteArrayToStructureBigEndian <rt27_1_11>(4); Console.WriteLine("{0} {1} {2}", ToDeg(test2.Latitude * Math.PI), ToDeg(test2.Longitude * Math.PI), test2.Altitude); } else if (record_type == 2) { var test2 = (rt27_2_19)gsof_msg.data.ByteArrayToStructureBigEndian <rt27_2_19>(4); Console.WriteLine("Event {0} {1} {2} {3}", test2.Source, test2.Port, test2.Number, test2.TOW); } else if (record_type == 6) // there is no documentation on this { if (page_number == 1) { obsdata.Initialize(); Array.ConstrainedCopy(gsof_msg.data, 0, obsdata, 0, gsof_msg.length); } else { Array.ConstrainedCopy(gsof_msg.data, 4, obsdata, 248 + (page_number - 2) * 244, gsof_msg.length - 4); } if (page_number == page_total) { var m_epochHeader = (rt27_6_27_epochHeader) obsdata.ByteArrayToStructureBigEndian <rt27_6_27_epochHeader>(4); var head_len = m_epochHeader.blockLength; var m_sysOffsets = new rt27_6_27_sysOffsets(); var obj = m_sysOffsets as object; MavlinkUtil.ByteArrayToStructureEndian(obsdata, ref obj, (4 + head_len)); m_sysOffsets = (rt27_6_27_sysOffsets)obj; var sysoffset_lemn = m_sysOffsets.blockLength; var m_measurement = new List <rt27_6_27_measurement>(); var SVs = m_epochHeader.nSVs; var offset = 4 + head_len + sysoffset_lemn; for (int index = 0; index < SVs; ++index) { var measheader = new rt27_6_27_measurementHeader(); obj = measheader as object; MavlinkUtil.ByteArrayToStructureEndian(obsdata, ref obj, offset); measheader = (rt27_6_27_measurementHeader)obj; var meashead_len = measheader.blockLength; offset += meashead_len; string type = ""; switch (measheader.svType) { case 0: type = "Gps"; break; case 1: type = "Sbas"; break; case 2: type = "Glonass"; break; case 3: type = "Galileo"; break; case 4: type = "QZSS"; break; case 7: type = "beidou"; break; } Console.WriteLine("prn {0} type {1} el {2} az {3} blocks {4}", measheader.prn, type, (double)(sbyte)measheader.elevation, (double)measheader.azimuth / Math.Pow(2.0, -1.0), measheader.nBlocks); for (int a = 0; a < measheader.nBlocks; a++) { var measblock = new rt27_6_27_measurementBlock(); obj = measblock as object; MavlinkUtil.ByteArrayToStructureEndian(obsdata, ref obj, offset); measblock = (rt27_6_27_measurementBlock)obj; if (a == 0) { Console.WriteLine("{0} {1}", measblock.pseudorange / Math.Pow(2.0, 7.0), byte2long(measblock.phase) / Math.Pow(2.0, 15.0)); } else { } var measblock_len = measblock.blockLength; offset += measblock_len; m_measurement.Add(new rt27_6_27_measurement() { block = measblock, header = measheader }); } } } } } if (gsof_msg.packettype == 0x40) // GSOF { uint8_t trans_number = gsof_msg.data[0]; uint8_t pageidx = gsof_msg.data[1]; uint8_t maxpageidx = gsof_msg.data[2]; //http://www.trimble.com/OEM_ReceiverHelp/V4.81/en/default.html //http://www.trimble.com/EC_ReceiverHelp/V4.19/en/GSOFmessages_Overview.htm Console.WriteLine("GSOF page: " + pageidx + " of " + maxpageidx); // want 2 8 9 38 for (uint a = 3; a < gsof_msg.length; a++) { uint8_t output_type = gsof_msg.data[a]; a++; uint8_t output_length = gsof_msg.data[a]; a++; Console.WriteLine("GSOF type: " + output_type + " len: " + output_length); if (output_type == 2) // position { state.location.lat = (int32_t)(ToDeg(SwapDouble(gsof_msg.data, a)) * 1e7); state.location.lng = (int32_t)(ToDeg(SwapDouble(gsof_msg.data, a + 8)) * 1e7); state.location.alt = (int32_t)(SwapDouble(gsof_msg.data, a + 16) * 1e2); state.last_gps_time_ms = state.time_week_ms; } else if (output_type == 8) // velocity { uint8_t vflag = gsof_msg.data[a]; if ((vflag & 1) == 1) { state.ground_speed = SwapFloat(gsof_msg.data, a + 1); state.ground_course = (float)(ToDeg(SwapFloat(gsof_msg.data, a + 5))); fill_3d_velocity(); state.velocity.Z = -SwapFloat(gsof_msg.data, a + 9); state.have_vertical_velocity = true; } } else if (output_type == 9) //dop { state.hdop = (uint16_t)(SwapFloat(gsof_msg.data, a + 4) * 100); } else if (output_type == 12) // position sigma { state.horizontal_accuracy = (SwapFloat(gsof_msg.data, a + 4) + SwapFloat(gsof_msg.data, a + 8)) / 2; state.vertical_accuracy = SwapFloat(gsof_msg.data, a + 16); state.have_horizontal_accuracy = true; state.have_vertical_accuracy = true; } else if (output_type == 1) // pos time { state.time_week_ms = SwapUint32(gsof_msg.data, a); state.time_week = SwapUint16(gsof_msg.data, a + 4); state.num_sats = gsof_msg.data[a + 6]; uint8_t posf1 = gsof_msg.data[a + 7]; uint8_t posf2 = gsof_msg.data[a + 8]; Console.WriteLine("POSTIME: " + posf1 + " " + posf2); if ((posf1 & 1) == 1) { state.status = AP_GPS.GPS_OK_FIX_3D; if ((posf2 & 1) == 1) { state.status = AP_GPS.GPS_OK_FIX_3D_DGPS; if ((posf2 & 4) == 4) { state.status = AP_GPS.GPS_OK_FIX_3D_RTK; } } } else { state.status = AP_GPS.NO_FIX; } } a += output_length - 1u; } Type t = state.GetType(); //where obj is object whose properties you need. FieldInfo[] pi = t.GetFields(); foreach (var p in pi) { System.Console.WriteLine(p.Name + " " + p.GetValue(state).ToString()); } return(true); } return(false); }
} //auto k_port_callback() { return m_k.bind(); } //auto p_port_callback() { return m_p.bind(); } //READ8_MEMBER( namco_53xx_device::K_r ) public u8 K_r(address_space space, offs_t offset, u8 mem_mask = 0xff) { return(m_k.op(0)); }
/* * * static uavcan_message_descriptor_s uavcan_protocol_file_Delete_res_descriptor = { * UAVCAN_PROTOCOL_FILE_DELETE_RES_DT_SIG, * UAVCAN_PROTOCOL_FILE_DELETE_RES_DT_ID, * CanardTransferTypeResponse, * sizeof(uavcan_protocol_file_Delete_res), * UAVCAN_PROTOCOL_FILE_DELETE_RES_MAX_PACK_SIZE, * encode_func, * decode_func, * null * }; */ static void encode_uavcan_protocol_file_Delete_res(uavcan_protocol_file_Delete_res msg, uavcan_serializer_chunk_cb_ptr_t chunk_cb, object ctx) { uint8_t[] buffer = new uint8_t[8]; _encode_uavcan_protocol_file_Delete_res(buffer, msg, chunk_cb, ctx, true); }
private bool parse(uint8_t temp) { switch (sbf_state) { case readstate.PREAMBLE1: if (temp == SBF_PREAMBLE1) { sbf_state++; } else if (temp == '$') { sbf_state++; } else { Console.Write("."); } sbf_msg.read = 0; break; case readstate.PREAMBLE2: if (temp == SBF_PREAMBLE2) { sbf_state++; } else if (temp == 'R') { validcommand = true; } else { Console.WriteLine("Bad Sync " + temp); sbf_state = readstate.PREAMBLE1; } break; case readstate.CRC1: sbf_msg.crc = temp; sbf_state++; break; case readstate.CRC2: sbf_msg.crc += (uint16_t)(temp << 8); sbf_state++; break; case readstate.BLOCKID1: sbf_msg.blockid = temp; sbf_state++; break; case readstate.BLOCKID2: sbf_msg.blockid += (uint16_t)(temp << 8); sbf_state++; break; case readstate.LENGTH1: sbf_msg.length = temp; sbf_state++; break; case readstate.LENGTH2: sbf_msg.length += (uint16_t)(temp << 8); sbf_state++; sbf_msg.data = new uint8_t[sbf_msg.length]; //Console.WriteLine((sbf_msg.blockid & 4095u) + " len " + sbf_msg.length); if (sbf_msg.length % 4 != 0) { sbf_state = readstate.PREAMBLE1; } break; case readstate.DATA: sbf_msg.data[sbf_msg.read] = temp; sbf_msg.read++; if (sbf_msg.read >= (sbf_msg.length - 8)) { uint16_t crc = crc16.ccitt(sbf_msg.blockid, 2, 0); crc = crc16.ccitt(sbf_msg.length, 2, crc); crc = crc16.ccitt(sbf_msg.data, sbf_msg.length - 8, crc); sbf_state = readstate.PREAMBLE1; if (sbf_msg.crc == crc) { return(process_message()); } else { crc_error_counter++; } } break; } return(false); }
public MyOctreeNode(TLeafData allContent) { ChildMask = 0; SetAllData(allContent); }
protected override void device_reset() { m_value = 0; }
public Mem(sqlite3 db, string z, double r, int i, int n, u16 flags, u8 type, u8 enc #if SQLITE_DEBUG , Mem pScopyFrom, object pFiller /* pScopyFrom, pFiller */ #endif ) { this.db = db; this.z = z; this.r = r; this.u.i = i; this.n = n; this.flags = flags; #if SQLITE_DEBUG this.pScopyFrom = pScopyFrom; this.pFiller = pFiller; #endif this.type = type; this.enc = enc; }
/* * * static uavcan_message_descriptor_s uavcan_equipment_air_data_StaticPressure_descriptor = { * UAVCAN_EQUIPMENT_AIR_DATA_STATICPRESSURE_DT_SIG, * UAVCAN_EQUIPMENT_AIR_DATA_STATICPRESSURE_DT_ID, * * CanardTransferTypeBroadcast, * * sizeof(uavcan_equipment_air_data_StaticPressure), * UAVCAN_EQUIPMENT_AIR_DATA_STATICPRESSURE_MAX_PACK_SIZE, * encode_func, * decode_func, * * null * * }; */ static void encode_uavcan_equipment_air_data_StaticPressure(uavcan_equipment_air_data_StaticPressure msg, uavcan_serializer_chunk_cb_ptr_t chunk_cb, object ctx) { uint8_t[] buffer = new uint8_t[8]; _encode_uavcan_equipment_air_data_StaticPressure(buffer, msg, chunk_cb, ctx, true); }
static void Main(string[] args) { System.SByte sb = SByte.MaxValue; System.Byte b = Byte.MaxValue; System.Int16 i16 = Int16.MaxValue; System.Int32 i32 = Int32.MaxValue; System.Int64 i64 = Int64.MaxValue; System.UInt16 ui16 = UInt16.MaxValue; System.UInt32 ui32 = UInt32.MaxValue; System.UInt64 ui64 = UInt64.MaxValue; System.Char ch = 'C'; System.Boolean bol = true; System.Single fl = Single.MaxValue; System.Double db = Double.MaxValue; System.Decimal dc = Decimal.MaxValue; System.String st = "Hello, world!"; System.Object obj = null; /* * Console.WriteLine( * $"sb={sb}\n" + * $"b={b}\n" + * $"i16={i16}\n" + * $"i32={i32}\n" + * $"i64={i64}\n" + * $"ui16={ui16}\n" + * $"ui32={ui32}\n" + * $"ui64={ui64}\n" + * $"ch={ch}\n" + * $"bol={bol}\n" + * $"fl={fl}\n" + * $"db={db}\n" + * $"dc={dc}\n" + * $"st={st}\n" + * $"obj={obj}\n");*/ byte b1 = 1; short b2 = b1; int b3 = b2; long b4 = b3; double b5 = b4; //Console.WriteLine(b5); double d1 = 1.543; long d2 = (long)d1; Console.WriteLine("d2={0}", d2); int i1 = Int32.MaxValue; short i2 = (short)i1; Console.WriteLine("i2={0}", i2); short s1 = 5545; byte s2 = (byte)s1; Console.WriteLine("s2={0}", s2); int I1 = -123; uint I2 = (uint)I1; Console.WriteLine("I2={0}", I2); double D1 = 4.123031777776333; float D2 = (float)D1; Console.WriteLine("D2={0}", D2); int X = 10; object Obj; Obj = X; int Y = (int)Obj; Console.WriteLine("Y={0}", Y); var Str = "Hello, world!"; Console.WriteLine(Str.GetType()); int?null1 = null; int null2 = null1 ?? 5; Console.WriteLine("null2={0}", null2); char[] a = { 'f', 'f', 'f', 'f' }; string a1 = new string(a); string a2 = new string('f', 4); Console.WriteLine(a1 == a2); string Str1 = "Hello"; string Str2 = ", "; string Str3 = "world!"; Console.WriteLine(String.Concat(Str1, Str2, Str3)); Console.WriteLine(); Console.WriteLine("--------------------------------------------"); string text = "Thisstring"; text = text.Insert(4, " is"); text = text.Insert(7, " a "); text = text.Insert(10, "My "); text = text.Remove(10, 3); string[] words = text.Split(' '); foreach (string s in words) { Console.WriteLine(s); } Console.WriteLine("--------------------------------------------"); string NullSt = ""; Console.WriteLine($"Length={NullSt.Length}"); Console.WriteLine("--------------------------------------------"); StringBuilder StrB = new StringBuilder("world"); StrB.Append("!!!!!"); StrB.Insert(0, "Beautiful "); Console.WriteLine(StrB); Console.WriteLine("--------------------------------------------"); int[][] Mas = new int[3][]; Mas[0] = new int[5] { 1, 2, 3, 4, 5 }; Mas[1] = new int[4] { 1, 2, 3, 4 }; Mas[2] = new int[4] { 1, 2, 3, 4 }; for (int i = 0; i < Mas.Length; i++) { for (int j = 0; j < Mas[i].Length; j++) { Console.Write($" {Mas[i][j]} "); } Console.WriteLine(); } Console.WriteLine(); Console.WriteLine("--------------------------------------------"); string[] MasStr = { "aaaaaaaaa", "11111111", "44444444444" }; Console.WriteLine($"Size MasStr={MasStr.Length}"); Console.WriteLine("Enter number and value\n"); int num = Int32.Parse(Console.ReadLine()); MasStr[num] = Console.ReadLine(); Console.WriteLine("--------------------------------------------"); Console.WriteLine(); for (int i = 0; i < MasStr.Length; i++) { Console.WriteLine(MasStr[i]); } Console.WriteLine(); Console.WriteLine("--------------------------------------------"); double[][] MasD = new double[3][]; for (int i = 0; i < MasD.Length; i++) { MasD[i] = new double[i + 1]; for (int j = 0; j < i + 1; j++) { MasD[i][j] = Double.Parse(Console.ReadLine()); } } for (int i = 0; i < MasD.Length; i++) { for (int j = 0; j < MasD[i].Length; j++) { Console.Write($" { MasD[i][j]} "); } Console.WriteLine(); } Console.WriteLine(); Console.WriteLine("--------------------------------------------"); var MasInt = new[] { 12.23, 323.2, 322 }; var MasString = new[] { "ABC", null }; ValueTuple <int, string, char, string, ulong> cortage = (1, "22", 'f', "rrr", UInt64.MaxValue); Console.WriteLine($"{cortage.Item1} {cortage.Item3} { cortage.Item4}"); int CorInt = cortage.Item1; string CorStr1 = cortage.Item2; string CorStr2 = cortage.Item4; char CorCh = cortage.Item3; ulong CorUl = cortage.Item5; int[] arr = new int[4] { 1, 2, 3, 4 }; var Typle = CreateCortage(arr, text); Console.WriteLine(Typle); Console.WriteLine("--------------------------------------------"); Console.ReadKey(); }
} //DECLARE_READ_LINE_MEMBER( bit5_q_r ) { return BIT(m_value, 5) ^ 1; } //DECLARE_READ_LINE_MEMBER( bit6_q_r ) { return BIT(m_value, 6) ^ 1; } //DECLARE_READ_LINE_MEMBER( bit7_q_r ) { return BIT(m_value, 7) ^ 1; } /* write bit x from data into bit determined by offset */ /* latch = (latch & ~(1<<offset)) | (((data >> x) & 0x01) << offset) */ public void bit0_w(address_space space, offs_t offset, u8 data, u8 mem_mask = 0xff) { bitx_w(0, offset, data); } //WRITE8_MEMBER( latch8_device::bit0_w ) { bitx_w(0, offset, data); }
/* * * static uavcan_message_descriptor_s uavcan_equipment_esc_RawCommand_descriptor = { * UAVCAN_EQUIPMENT_ESC_RAWCOMMAND_DT_SIG, * UAVCAN_EQUIPMENT_ESC_RAWCOMMAND_DT_ID, * * CanardTransferTypeBroadcast, * * sizeof(uavcan_equipment_esc_RawCommand), * UAVCAN_EQUIPMENT_ESC_RAWCOMMAND_MAX_PACK_SIZE, * encode_func, * decode_func, * * null * * }; */ static void encode_uavcan_equipment_esc_RawCommand(uavcan_equipment_esc_RawCommand msg, uavcan_serializer_chunk_cb_ptr_t chunk_cb, object ctx) { uint8_t[] buffer = new uint8_t[8]; _encode_uavcan_equipment_esc_RawCommand(buffer, msg, chunk_cb, ctx, true); }
/* * * static uavcan_message_descriptor_s uavcan_protocol_param_GetSet_req_descriptor = { * UAVCAN_PROTOCOL_PARAM_GETSET_REQ_DT_SIG, * UAVCAN_PROTOCOL_PARAM_GETSET_REQ_DT_ID, * CanardTransferTypeRequest, * sizeof(uavcan_protocol_param_GetSet_req), * UAVCAN_PROTOCOL_PARAM_GETSET_REQ_MAX_PACK_SIZE, * encode_func, * decode_func, * &uavcan_protocol_param_GetSet_res_descriptor * }; */ static void encode_uavcan_protocol_param_GetSet_req(uavcan_protocol_param_GetSet_req msg, uavcan_serializer_chunk_cb_ptr_t chunk_cb, object ctx) { uint8_t[] buffer = new uint8_t[8]; _encode_uavcan_protocol_param_GetSet_req(buffer, msg, chunk_cb, ctx, true); }