PWS-1

The PWS-1 was a Polish two-seat fighter and reconnaissance aircraft, constructed by Podlaska Wytwórnia Samolotów (PWS) in 1927, which remained a prototype.

PWS-1
PWS-1
Role Fighter aircraft
Manufacturer Podlaska Wytwórnia Samolotów
First flight 25 April 1927
Status prototype
Primary user Polish Air Force
Number built 1

Design and development

The PWS-1 was the first design of the Podlaska Wytwórnia Samolotów (Podlasie Aircraft Factory), and the second aircraft designed and built in Poland, after the CWL WZ-X. It was conceived as a single-engine high-wing two-seat fighter, a main purpose of which was the escorting of bombers. Design work was carried in 1926 by Zbysław Ciołkosz and Aleksander Grzędzielski, under direction of Stanisław Cywiński.

After static tests, the prototype first flew on 25 April 1927 in Biała Podlaska. Tests revealed poor manoeuvrability, its speed was also low due to a thick wing, despite STOL capability.

In 1928 the aircraft was reworked, receiving a new, lighter, straight wing of thinner profile and duralumin construction instead of a wooden, slightly swept one. It also received an enormous vertical stabilizer of rectangular shape with rounded top. After modifications it was flown in early 1929, under a designation PWS-1bis. Its performance improved, but because of its relatively low speed compared to other fighters, its primary role was changed to reconnaissance. Development was however discontinued, because it had little payload, and in a meantime Poland had bought large numbers of better Breguet 19 and Potez 25 reconnaissance and bomber aircraft.

Description
PWS-1bis

High-wing parasol braced monoplane of mixed construction, with single engine. A fuselage of a steel frame in front and wooden frame in the rear, covered with canvas and duralumin in engine section. Slightly swept wing of wooden construction, plywood and canvas covered, two spar (PWS-1) or straight duralumin wing, of trapezoid-rectangular shape, two-spar, plywood and canvas covered (PWS-1bis). Stabilizers, rudder and elevator of wooden construction, canvas covered. Open pilot's cab, with a windshield, behind it an open observer's cab with two 7.7 mm Lewis machine guns on a ring mounting. Cabs had twin controls. Pilot manned two 7.7 mm Vickers machine guns fixed in a fuselage, with an interrupter gear. Conventional fixed landing gear, with a rear skid.

Engine:Lorraine-Dietrich 12Eb water-cooled inline W-12, built in Polish Skoda Works. Water radiator before the engine. Two-blade wooden propeller of a fixed pitch. Fuel tank 375 l in the forward fuselage front, jettisonable in an emergency.

Specifications (PWS 1bis)

Data from Jane's all the World's Aircraft 1928[1], Polish Aircraft 1893–1939[2]

General characteristics

  • Crew: 2
  • Length: 8.375 m (27 ft 6 in)
  • Wingspan: 12.65 m (41 ft 6 in)
  • Height: 3.34 m (10 ft 11 in)
  • Wing area: 30.5 m2 (328 sq ft)
  • Airfoil: Bobek-Zdanewski No.4 (Göttingen 648)
  • Empty weight: 1,445 kg (3,186 lb)
  • Gross weight: 1,990 kg (4,387 lb)
  • Fuel capacity: 375 l (99 US gal; 82 imp gal)
  • Powerplant: 1 × Lorraine-Dietrich 12Eb W-12 water-cooled piston engine, 340 kW (450 hp)
  • Propellers: 2-bladed wooden fixed pitch propeller

Performance

  • Maximum speed: 232 km/h (144 mph, 125 kn) at sea level; 210 km/h (130 mph; 110 kn) at 5,000 m (16,000 ft)
  • Landing speed:98 km/h (61 mph; 53 kn)
  • Range: 750 km (470 mi, 400 nmi)
  • Service ceiling: 6,000 m (20,000 ft) at normal weight
  • Rate of climb: 5.4 m/s (1,060 ft/min)
  • Time to altitude: 1,000 m (3,300 ft) in 3 minutes 25 seconds; 3,000 m (9,800 ft) in 13 minutes
  • Wing loading: 65.4 kg/m2 (13.4 lb/sq ft)
  • Power/mass: 0.1031 hp/lb (0.1695 kW/kg)

Armament
2 x fixed forward firing synchronised 7.7 mm (0.303 in) Vickers machine guns; 2 x flexibly mounted 7.7 mm (0.303 in) Lewis machine guns in the rear cockpit

gollark: I can come up with a thing to transmit ubqmachine™ details to osmarks.net or whatever which people can embed in their code.
gollark: It's an x86-64 system using debian or something.
gollark: > `import hashlib`Hashlib is still important!> `for entry, ubq323 in {**globals(), **__builtins__, **sys.__dict__, **locals(), CONSTANT: Entry()}.items():`Iterate over a bunch of things. I think only the builtins and globals are actually used.The stuff under here using `blake2s` stuff is actually written to be ridiculously unportable, to hinder analysis. This caused issues when trying to run it, so I had to hackily patch in the `/local` thing a few minutes before the deadline.> `for PyObject in gc.get_objects():`When I found out that you could iterate over all objects ever, this had to be incorporated somehow. This actually just looks for some random `os` function, and when it finds it loads the obfuscated code.> `F, G, H, I = typing(lookup[7]), typing(lookup[8]), __import__("functools"), lambda h, i, *a: F(G(h, i))`This is just a convoluted way to define `enumerate(range))` in one nice function.> `print(len(lookup), lookup[3], typing(lookup[3])) #`This is what actually loads the obfuscated stuff. I think.> `class iｎt(typing(lookup[0])):`Here we subclass `complex`. `complex` is used for 2D coordinates within the thing, so I added some helper methods, such as `__iter__`, allowing unpacking of complex numbers into real and imaginary parts, `abs`, which generates a complex number a+ai, and `ℝ`, which provvides the floored real parts of two things.> `class Mаtrix:`This is where the magic happens. It actually uses unicode homoglyphs again, for purposes.> `self = typing("dab7d4733079c8be454e64192ce9d20a91571da25fc443249fc0be859b227e5d")`> `rows = gc`I forgot what exactly the `typing` call is looking up, but these aren't used for anything but making the fake type annotations work.> `def __init__(rows: self, self: rows):`This slightly nonidiomatic function simply initializes the matrix's internals from the 2D array used for inputs.> `if 1 > (typing(lookup[1]) in dir(self)):`A convoluted way to get whether something has `__iter__` or not.
gollark: If you guess randomly the chance of getting none right is 35%ish.
gollark: Anyway, going through #12 in order:> `import math, collections, random, gc, hashlib, sys, hashlib, smtplib, importlib, os.path, itertools, hashlib`> `import hashlib`We need some libraries to work with. Hashlib is very important, so to be sure we have hashlib we make sure to keep importing it.> `ℤ = int`> `ℝ = float`> `Row = "__iter__"`Create some aliases for int and float to make it mildly more obfuscated. `Row` is not used directly in anywhere significant.> `lookup = [...]`These are a bunch of hashes used to look up globals/objects. Some of them are not actually used. There is deliberately a comma missing, because of weird python string concattey things.```pythondef aes256(x, X): import hashlib A = bytearray() for Α, Ҙ in zip(x, hashlib.shake_128(X).digest(x.__len__())): A.append(Α ^ Ҙ) import zlib, marshal, hashlib exec(marshal.loads(zlib.decompress(A)))```Obviously, this is not actual AES-256. It is abusing SHAKE-128's variable length digests to implement what is almost certainly an awful stream cipher. The arbitrary-length hash of our key, X, is XORed with the data. Finally, the result of this is decompressed, loaded (as a marshalled function, which is extremely unportable bytecode I believe), and executed. This is only used to load one piece of obfuscated code, which I may explain later.> `class Entry(ℝ):`This is also only used once, in `typing` below. Its `__init__` function implements Rule 110 in a weird and vaguely golfy way involving some sets and bit manipulation. It inherits from float, but I don't think this does much.> `#raise SystemExit(0)`I did this while debugging the rule 110 but I thought it would be fun to leave it in.> `def typing(CONSTANT: __import__("urllib3")):`This is an obfuscated way to look up objects and load our obfuscated code.> `return getattr(Entry, CONSTANT)`I had significant performance problems, so this incorporates a cache. This was cooler™️ than dicts.

References
  1. Grey, C.G., ed. (1928). Jane's all the World's Aircraft 1928. London: Sampson Low, Marston & company, ltd. pp. 179c.
  2. Cynk, Jerzy B. (1971). Polish Aircraft 1893–1939. London: Putnam. ISBN 978-0-370-00085-5.
  • Andrzej Glass: "Polskie konstrukcje lotnicze 1893-1939" (Polish aviation constructions 1893-1939), WKiŁ, Warsaw 1977 (Polish language, no ISBN)
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.