Merancang Kosmos: Mengimplementasikan Sistem Komunikasi Satelit dengan TypeScript

            // Mendefinisikan jenis orbit untuk satelit
export enum OrbitType {
    LEO = 'Low Earth Orbit',
    MEO = 'Medium Earth Orbit',
    GEO = 'Geostationary Orbit',
    HEO = 'Highly Elliptical Orbit',
}

// Mewakili parameter orbital kunci (elemen Keplerian)
export interface OrbitalParameters {
    semiMajorAxis_km: number;       // Ukuran orbit
    eccentricity: number;           // Bentuk orbit (0 untuk melingkar)
    inclination_deg: number;        // Kemiringan orbit relatif terhadap ekuator
    raan_deg: number;               // Right Ascension of the Ascending Node (putaran orbit)
    argumentOfPeriapsis_deg: number;// Orientasi orbit di dalam bidangnya
    trueAnomaly_deg: number;        // Posisi satelit di sepanjang orbit pada epoch tertentu
    epoch: Date;                    // Waktu referensi untuk parameter ini
}

// Mendefinisikan status kesehatan dari subsistem satelit
export interface SubsystemStatus {
    name: 'Power' | 'Propulsion' | 'Thermal' | 'Communications';
    status: 'Nominal' | 'Warning' | 'Error' | 'Offline';
    voltage_V?: number;
    temperature_C?: number;
    pressure_kPa?: number;
}

// Model satelit inti
export interface Satellite {
    id: string;                     // Pengidentifikasi unik, mis., 'SAT-001'
    name: string;                   // Nama umum, mis., 'GlobalCom-1A'
    orbit: OrbitType;
    parameters: OrbitalParameters;
    subsystems: SubsystemStatus[];
}

            

              
                Copy
              
            
          

            export interface GeoLocation {
    latitude_deg: number;
    longitude_deg: number;
    altitude_m: number;
}

// Mendefinisikan pita frekuensi yang dapat dioperasikan oleh stasiun darat
export enum FrequencyBand {
    S_BAND = 'S-Band',
    C_BAND = 'C-Band',
    X_BAND = 'X-Band',
    KU_BAND = 'Ku-Band',
    KA_BAND = 'Ka-Band',
}

export interface GroundStation {
    id: string; // mis., 'GS-EU-1' (Stasiun Darat, Eropa 1)
    name: string; // mis., 'Fucino Space Centre'
    location: GeoLocation;
    availableBands: FrequencyBand[];
    uplinkRate_bps: number;
    downlinkRate_bps: number;
    status: 'Online' | 'Offline' | 'Maintenance';
}

            

              
                Copy
              
            
          

            // Struktur dasar untuk setiap paket yang datang dari satelit
interface BasePacket {
    satelliteId: string;
    timestamp: number; // Stempel waktu Unix dalam milidetik
    sequenceNumber: number;
}

// Paket khusus untuk status kesehatan subsistem
export interface HealthStatusPacket extends BasePacket {
    packetType: 'HEALTH_STATUS';
    payload: SubsystemStatus[];
}

// Paket khusus untuk data ilmiah, mis., dari muatan pencitraan
export interface ScienceDataPacket extends BasePacket {
    packetType: 'SCIENCE_DATA';
    payload: {
        instrumentId: string;
        dataType: 'image/jpeg' | 'application/octet-stream';
        data: Buffer; // Data biner mentah
    };
}

// Paket khusus untuk mengakui perintah yang diterima
export interface CommandAckPacket extends BasePacket {
    packetType: 'COMMAND_ACK';
    payload: {
        commandSequenceNumber: number;
        status: 'ACK' | 'NACK'; // Diakui atau Tidak Diakui
        reason?: string; // Alasan opsional untuk NACK
    };
}

// Serikat dari semua kemungkinan jenis paket telemetri
export type TelemetryPacket = HealthStatusPacket | ScienceDataPacket | CommandAckPacket;

// Fungsi prosesor yang menangani berbagai jenis paket dengan aman
function processTelemetry(packet: TelemetryPacket): void {
    console.log(`Memproses paket #${packet.sequenceNumber} dari ${packet.satelliteId}`);

    switch (packet.packetType) {
        case 'HEALTH_STATUS':
            // TypeScript mengetahui `packet` bertipe HealthStatusPacket di sini
            console.log('Pembaruan Status Kesehatan Diterima:');
            packet.payload.forEach(subsystem => {
                console.log(`  - ${subsystem.name}: ${subsystem.status}`);
            });
            break;

        case 'SCIENCE_DATA':
            // TypeScript mengetahui `packet` bertipe ScienceDataPacket di sini
            console.log(`Data Ilmiah Diterima dari instrumen ${packet.payload.instrumentId}.`);
            // Logika untuk menyimpan buffer data ke file atau database
            saveScienceData(packet.payload.data);
            break;

        case 'COMMAND_ACK':
            // TypeScript mengetahui `packet` bertipe CommandAckPacket di sini
            console.log(`Status #${packet.payload.commandSequenceNumber}: ${packet.payload.status}`);
            if (packet.payload.status === 'NACK') {
                console.error(`Alasan: ${packet.payload.reason}`);
            }
            break;

        default:
            // Bagian ini sangat penting. TypeScript dapat melakukan pemeriksaan yang lengkap.
            // Jika kita menambahkan jenis paket baru ke serikat dan lupa untuk menanganinya di sini,
            // kompiler akan memunculkan kesalahan.
            const _exhaustiveCheck: never = packet;
            console.error(`Jenis paket yang tidak tertangani: ${_exhaustiveCheck}`);
            return _exhaustiveCheck;
    }
}

function saveScienceData(data: Buffer) { /* Implementasi dihilangkan */ }

            

              
                Copy
              
            
          

            // Struktur dasar untuk setiap perintah yang dikirim ke satelit
interface BaseCommand {
    commandId: string; // ID unik untuk instance perintah ini
    sequenceNumber: number;
    targetSatelliteId: string;
}

// Perintah untuk menyesuaikan sikap (orientasi) satelit
export interface SetAttitudeCommand extends BaseCommand {
    commandType: 'SET_ATTITUDE';
    parameters: {
        quaternion: { w: number; x: number; y: number; z: number; };
        slewRate_deg_s: number;
    };
}

// Perintah untuk mengaktifkan atau menonaktifkan muatan tertentu
export interface SetPayloadStateCommand extends BaseCommand {
    commandType: 'SET_PAYLOAD_STATE';
    parameters: {
        instrumentId: string;
        state: 'ACTIVE' | 'STANDBY' | 'OFF';
    };
}

// Perintah untuk melakukan manuver penjagaan stasiun
export interface ExecuteManeuverCommand extends BaseCommand {
    commandType: 'EXECUTE_MANEUVER';
    parameters: {
        thrusterId: string;
        burnDuration_s: number;
        thrustVector: { x: number; y: number; z: number; };
    };
}

// Serikat dari semua kemungkinan jenis perintah
export type Telecommand = SetAttitudeCommand | SetPayloadStateCommand | ExecuteManeuverCommand;

// Fungsi untuk menserialisasi perintah ke dalam format biner untuk uplink
function serializeCommand(command: Telecommand): Buffer {
    // Implementasinya akan mengonversi objek perintah terstruktur
    // ke dalam protokol biner tertentu yang dipahami oleh satelit.
    console.log(`Menserialisasi perintah ${command.commandType} untuk ${command.targetSatelliteId}...`);
    
    // 'switch' di sini memastikan setiap jenis perintah ditangani dengan benar.
    // Keamanan tipe menjamin bahwa 'command.parameters' akan memiliki bentuk yang tepat.
    switch (command.commandType) {
        case 'SET_ATTITUDE':
            // Logika untuk mengemas quaternion dan laju putar ke dalam buffer
            break;
        case 'SET_PAYLOAD_STATE':
            // Logika untuk mengemas ID instrumen dan enum status ke dalam buffer
            break;
        case 'EXECUTE_MANEUVER':
            // Logika untuk mengemas detail pendorong ke dalam buffer
            break;
    }
    
    // Tempat penampung untuk data biner yang sebenarnya
    return Buffer.from(JSON.stringify(command)); 
}

            

              
                Copy
              
            
          

            // Fungsi yang disederhanakan untuk menghitung penundaan kecepatan cahaya satu arah
function getSignalLatency_ms(satellite: Satellite, station: GroundStation): number {
    // Dalam sistem nyata, ini akan melibatkan mekanika orbital yang kompleks untuk menghitung
    // jarak yang tepat antara satelit dan stasiun darat.
    const speedOfLight_km_s = 299792.458;
    let distance_km: number;

    switch (satellite.orbit) {
        case OrbitType.LEO: distance_km = 1000; break; // Rata-rata yang disederhanakan
        case OrbitType.MEO: distance_km = 15000; break;
        case OrbitType.GEO: distance_km = 35786; break;
        default: distance_km = 5000;
    }
    
    return (distance_km / speedOfLight_km_s) * 1000; // Kembalikan dalam milidetik
}

// Utilitas untuk membuat penundaan
const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));

// Layanan untuk mengirim perintah dan menunggu pengakuan
class CommunicationService {
    async sendCommand(command: Telecommand, groundStation: GroundStation, targetSatellite: Satellite): Promise {
        console.log(`[${new Date().toISOString()}] Mengirim perintah ${command.commandType} melalui ${groundStation.name}...`);
        
        const uplinkLatency = getSignalLatency_ms(targetSatellite, groundStation);
        const downlinkLatency = uplinkLatency; // Asumsi yang disederhanakan
        
        // 1. Serialisasikan perintah untuk transmisi
        const commandData = serializeCommand(command);

        // 2. Simulasikan penundaan uplink
        await sleep(uplinkLatency);
        console.log(`[${new Date().toISOString()}] Sinyal perintah mencapai ${targetSatellite.name}.`);

        // Dalam sistem nyata, bagian ini akan menjadi permintaan jaringan ke perangkat keras stasiun darat.
        // Di sini kita mensimulasikan satelit yang menerimanya dan segera mengirimkan ACK.
        const satelliteProcessingTime_ms = 50;
        await sleep(satelliteProcessingTime_ms);

        // 3. Simulasikan penundaan downlink untuk pengakuan
        console.log(`[${new Date().toISOString()}] Satelit mengirimkan pengakuan...`);
        await sleep(downlinkLatency);
        console.log(`[${new Date().toISOString()}] Pengakuan diterima di ${groundStation.name}.`);

        // 4. Kembalikan paket pengakuan tiruan
        const ackPacket: CommandAckPacket = {
            satelliteId: targetSatellite.id,
            timestamp: Date.now(),
            sequenceNumber: command.sequenceNumber + 1, // Logika contoh
            packetType: 'COMMAND_ACK',
            payload: {
                commandSequenceNumber: command.sequenceNumber,
                status: 'ACK',
            }
        };
        
        return ackPacket;
    }
}

            

              
                Copy
              
            
          

            // Definisikan berbagai jenis muatan data ilmiah
interface SpectrometerData {
    wavelengths_nm: number[];
    intensities: number[];
}

interface ImagingData {
    resolution: { width: number; height: number; };
    format: 'RAW' | 'JPEG';
    imageData: Buffer;
}

// Paket sains generik yang dapat menyimpan jenis muatan apa pun
interface GenericSciencePacket extends BasePacket {
    packetType: 'SCIENCE_DATA';
    payload: {
        instrumentId: string;
        data: T;
    };
}

// Buat jenis paket tertentu menggunakan generik
type SpectrometerPacket = GenericSciencePacket;
type ImagingPacket = GenericSciencePacket;

// Kelas prosesor generik
class DataProcessor {
    process(packet: GenericSciencePacket): void {
        console.log(`Memproses data dari instrumen ${packet.payload.instrumentId}`);
        // Logika pemrosesan generik di sini...
        this.saveToDatabase(packet.payload.data);
    }

    private saveToDatabase(data: T) {
        // Logika penyimpanan database aman-tipe untuk muatan bertipe T
        console.log('Data disimpan.');
    }
}

// Buat contoh prosesor untuk jenis data tertentu
const imagingProcessor = new DataProcessor();
const spectrometerProcessor = new DataProcessor();

// Contoh penggunaan
const sampleImagePacket: ImagingPacket = { /* ... */ };
imagingProcessor.process(sampleImagePacket); // Ini berfungsi

// Baris berikut akan menyebabkan kesalahan waktu kompilasi, mencegah pemrosesan yang salah:
// spectrometerProcessor.process(sampleImagePacket); // Kesalahan: Argumen bertipe 'ImagingPacket' tidak dapat ditetapkan ke parameter bertipe 'GenericSciencePacket'.

            

              
                Copy
              
            
          

            // Definisikan potensi jenis kesalahan
interface CommunicationError {
    type: 'Timeout' | 'SignalLost' | 'InvalidChecksum';
    message: string;
}

// Tipe Result yang dapat berupa keberhasilan (Ok) atau kegagalan (Err)
type Result = { ok: true; value: T } | { ok: false; error: E };

// sendCommand yang dimodifikasi untuk mengembalikan Result
async function sendCommandSafe(
    command: Telecommand
): Promise> {
    try {
        // ... simulasi mengirim perintah ...
        const isSuccess = Math.random() > 0.1; // Simulasikan tingkat kegagalan 10%

        if (!isSuccess) {
            return { ok: false, error: { type: 'SignalLost', message: 'Uplink signal lost during transmission.' } };
        }

        const ackPacket: CommandAckPacket = { /* ... */ };
        return { ok: true, value: ackPacket };

    } catch (e) {
        return { ok: false, error: { type: 'Timeout', message: 'No response from satellite.' } };
    }
}

// Kode panggilan sekarang harus secara eksplisit menangani kasus kegagalan
async function runCommandSequence() {
    const command: SetAttitudeCommand = { /* ... */ };
    const result = await sendCommandSafe(command);

    if (result.ok) {
        // TypeScript mengetahui `result.value` adalah CommandAckPacket di sini
        console.log(`Berhasil! Perintah diakui:`, result.value.payload.status);
    } else {
        // TypeScript mengetahui `result.error` adalah CommunicationError di sini
        console.error(`Perintah gagal: [${result.error.type}] ${result.error.message}`);
        // Picu rencana darurat...
    }
}

            

              
                Copy