Zobrazit příspěvky
Tato sekce Vám umožňuje zobrazit všechny příspěvky tohoto uživatele. Prosím uvědomte si, že můžete vidět příspěvky pouze z oblastí Vám přístupných.
Aha, to jsem špatně pochopil, myslel jsem, že mu jde o P2P. Pokud ne, tak tam může dát jako AP třeba Ubiquiti UAP-AC-M
zalezi, aka rychlost. ak je to na bezne surfovanie, tak by mohol stacit nejaky nanostation, alebo mikrotik. Ale tie stromy, tak radsej 2.4Ghz, to prelezie v pohode na 200m aj cez jednu stenu panelaku
Skusil by som ale zmenit polarizaciu. ist do horizontalnej. To by mohlo trocha pomoct.
Tohle by mělo být hlavně o anténě. Podle plánku 60° sektor s co nejlepším ziskem a na připojeném zařízení tomu případně přidat na 30dBm. To by řešilo hlavně download, ale těch pár bajtů uploadu by snad taky prošlo. Chce to zkoušet, objednat to přes NET a když tak vrátit.
....
vypada to pekne na pohled, ale ten atom je dost bidny procak, co?!
Dát TV, mobily, smarthome, atd. do oddělených VLAN je sice nápad dobrej, ale v praxi dost z toho naráží na mDNS. Mikrotik to "neumí" forwardovat mezi VLANama, takže z mobilu neuděláte Miracast/AirPlay/Spotify Connect/..., nevytisknete si nic na tiskárně ani si nenastavíte např. Ikea Tradfri Gateway nebo HomeKit.
Mikrotik RB2011 je celkem starý a pomalý, je možné, že narazíte na výkonnostní strop (zejména u pps). Na rychlou VPN a podobné náročnější věci zapomeňte. Stejný výkon procesoru má i switch Mikrotik CRS326-24G-2S+RM, kterým byste vyřešil vše v jednom včetně podpory VLAN. Cena je ale o pár stovek vyšší.
Vzhledem k tomu, jak byl formulován dotaz, pravdu má. Pokud by autorovi dotazu na správném návrhu sítě nezáleželo, neptal by se na to a použil by první router, který by mu padnul pod ruku v kombinaci s libovolným switchem. To ale dle všeho není ten případ, dokonce sám např. VLANy zmínil.
Otazka ale je, jestli je zmínil proto, ze vi, co to je, a nebo simomtom nekde precetl, a z toho jen ziskal pocit, ze je nutne potrebuje.
...
100mbit wifi AP) do router-u (1x) (nepredpokladám, investicie sa nebojí)...Ved tam tiez udajne sirili dezinformacie, ktore sa neskor ukazali ako pravdive. Takisto isli proti prudu. ...Mozete dolozit link? Prosim link na dezinformaciu a link na zdroj ktory potvrdil ze dezinformacia bola pravdiva
Neskor sa ukazalo, aspon v CR, ze opatrenia boli nezakonne a zrusene.Mozete mi tak isto dodat zdroj?
Prisiel konflikt a zrazu prask, mame genialny dovod zrusit weby a zacat s "demokratickou" cenzurou.Demokraticka cenzura neexistuje. Demokracia je vlada vacsiny... Cenzura je ucelne obmedzovanie informacii
/* temp */
/* use MYSQL::Connection; */
pub struct Connection {}
impl Connection {
pub fn execute(/* ... */){/* ... */}
}
pub enum DatabaseMembers {
X,
Y,
Z
}
// Various Structs
pub struct X {
pub name: String
}
pub struct Y {
pub text: String
}
pub struct Z {
pub value: u64
}
/* Traits */
pub trait CreateTable {
fn create_table(c: &Connection) -> Result<(), Error>;
fn table_type() -> DatabaseMembers;
}
pub trait FromDatabase : Sized {
fn get(c: &Connection) -> Result<Self, Error>;
}
pub trait ToDatabase {
fn push(c: &Connection, data: &Self) -> Result<(), Error>;
}
/* Trait implementation */
/* Impl for X */
impl CreateTable for X {
fn table_type() -> DatabaseMembers{
DatabaseMembers::X;
}
fn create_table(c: &Connection) -> Result<(), Error>{
let query =
"CREATE TABLE IF NOT EXISTS X (
id INTEGER PRIMARY KEY,
text TEXT NOT NULL,
);";
Ok(())
}
}
impl ToDatabase for X {
fn push(c: &Connection, data: &Self) -> Result<(), PError> {
let query =
"INSERT INTO ...
(name, ...)
VALUES
(?1, ...)
";
}
}
impl FromDatabase for X {
fn get(c: &Connection, id: usize) -> Result<Self, Error>{
let query =
"SELECT *
FROM ...
WHERE ... id=?1
";
/* ... */
Ok(X{ /*... */})
}
}
/* Impl for Y */
impl CreateTable for Y {
fn table_type() -> DatabaseMembers{
DatabaseMembers::Y;
}
fn create_table(c: &Connection) -> Result<(), Error>{
let query =
"CREATE TABLE IF NOT EXISTS Y (
id INTEGER PRIMARY KEY,
text TEXT NOT NULL,
);";
Ok(())
}
}
impl ToDatabase for Y {
fn push(c: &Connection, data: &Self) -> Result<(), PError> {
let query =
"INSERT INTO ...
(name, ...)
VALUES
(?1, ...)
";
}
}
impl FromDatabase for Y {
fn get(c: &Connection, id: usize) -> Result<Self, Error>{
let query =
"SELECT *
FROM ...
WHERE ... id=?1
";
/* ... */
Ok(Y{ /*... */})
}
}
/* Impl for Z */
/* ... */
pub struct Database {
c: Connection,
initialized_tables: Vec<DatabaseTables>,
}
impl Database {
pub fn open_temporary() -> Database {
let mut db = Database {
c: Connection::open_in_memory(),
}
/* ... */
Ok(db)
}
/* (1) - Explicitne vytvorim tabulku ...*/
pub fn create_table<T: CreateTable>(&mut self) -> Result<(), PError> {
if !self.initialized_tables.contains(&T::table_type()) {
let dbtable = T::create_table(&self.conn)?;
self.initialized_tables.push(dbtable);
}
Ok(())
}
pub fn push<T: CreateTable + ToDatabase>(&mut self, data: &T) {
/* (2) - alebo implicitne vytvorim tabulku */
if !self.initialized_tables.contains(&T::table_type()) {
T::create_table(&self.conn)?;
self.initialized_tables.push(&T::table_type());
}
ToDatabase::push(&self.conn, data)
}
pub fn get<T: FromDatabase>(&self, id: usize) -> Result<T, PError>{
FromDatabase::get(&self.conn, uid)
}
}
fn main() {
let mut db: Database = Database::open_temporary();
/* (1) - explicitne vytvorim tabulku pre X */
db.create_table::<X>();
let x = X {name: String::from("Ahoj")};
db.push(&x);
// (2) - implicitne vytvorim tabulku pre Y */
let y = Y {text: String::from("Ahoj")};
db.push(&y);
}
OP: Došel jsi prosímtě k něčemu? Zafungoval Ti ten "untagged"?
use serde_repr::*;
use serde::{Deserialize, Serialize};
#[derive(Serialize_repr, Deserialize_repr, PartialEq, Debug)]
#[serde(untagged)]
#[repr(u8)]
pub enum MessageBodyType {
Version = 11,
BatteryHealth = 22,
}
#[derive(Serialize, Deserialize, PartialEq, Debug)]
pub enum MessageBody {
Version(Version),
BatteryHealth(BatteryHealth),
}
impl MessageBody {
pub fn value(&self) -> MessageBodyType {
match *self {
MessageBody::Version(_) => MessageBodyType::Version,
MessageBody::BatteryHealth(_) => MessageBodyType::BatteryHealth
}
}
}
#[derive(Serialize, Deserialize, PartialEq, Debug)]
#[repr(C)]
pub struct MessageHeader {
message_type: MessageBodyType, // 1
_pad0: u8, // 1
body_size: u16, // 2
crc: u32, // 4
}
#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct Message {
header: MessageHeader,
body: MessageBody,
}
impl Message {
pub fn serialize_body(mb: MessageBody) -> Result<Vec<u8>, Error> {
let mut body_vec: Vec<u8>;
match &mb {
MessageBody::Version(v) => {
body_vec = bincode::serialize(&v)?;
},
MessageBody::BatteryHealth(h) => {
body_vec = bincode::serialize(&h)?;
}
}
let header : MessageHeader = MessageHeader {
message_type: mb.value(),
_pad0: HEADER_PAD,
body_size: body_vec.len() as u32,
crc: 0,
};
let mut header_vec = bincode::serialize(&header)?;
header_vec.append(&mut body_vec);
Ok(header_vec)
}
pub fn deserialize_body<'a>(bytes: &'a [u8]) -> Result<MessageBody, Error> {
if bytes.len() < std::mem::size_of::<MessageHeader>(){
return Err(());
}
let message_header_len = std::mem::size_of::<MessageHeader>();
match header.message_type {
MessageBodyType::Version => {
let version: Version = bincode::deserialize(&bytes[message_header_len..bytes.len()])?;
return Ok(MessageBody::Version(version));
},
MessageBodyType::BatteryHealth => {
let battery: BatteryHealth = bincode::deserialize(&bytes[message_header_len..bytes.len()])?;
return Ok(MessageBody::BatteryHealth(battery));
}
}
}
}
#[derive(Serialize, Deserialize, PartialEq, Debug)]
#[repr(C)]
pub struct Version {
pub x1: u8, // 1
pub x2: u8, // 1
pub x3: u16, // 2
}
#[derive(Serialize, Deserialize, PartialEq, Debug)]
#[repr(C)]
pub struct BatteryHealth {
pub x1: u8, // 1
pub x2: u8, // 1
pub x3: u16, // 2
}
fn main () -> Result<(), Box<(dyn std::error::Error + 'static)>> {
let serialized_version: Vec<u8> = Message::serialize(MessageBody::Version(Version{x1: 3, x2: 6, x3: 0xFAFA})).unwrap();
let serialized_battery: Vec<u8> = Message::serialize(MessageBody::BatteryHealth(BatteryHealth{x1: 10, x2: 20, x3: 0x0A0A})).unwrap();
let deserialized_version: MessageBody = Message::deserialize(&serialized_version).unwrap();
Ok(())
}
Root.cz (www.root.cz), informace nejen ze světa Linuxu. ISSN 1212-8309
Copyright © 1998 – 2024 Internet Info, s.r.o. Všechna práva vyhrazena. Powered by Linux.