MCU

MCU.swift

//
//  MCUPacketDevice.swift
//  APSMSwift
//
//  Created by APP559 on 2014/7/30.
//  Copyright (c) 2014年 yume. All rights reserved.
//

import UIKit

//MARK: Protocol

protocol Constructible {
    init()
}

protocol Packable{
    func pack() -> NSMutableData!
}

protocol Unpackable{
    mutating func unpack(data:NSData?)
}

//MARK: Header

struct devicePacketHeader:Packable,Unpackable{
    
    enum commandType : Byte{
        case ASK_DEVICE = 0
        case ASK_VERSION = 8
        case SEND_PASSWORD = 10
        case RADIO = 20
        case READ_PARAMETERS = 21
        case SAVE_PARAMETERS = 22
        case UPDATE_PARAMETER = 23
        case DEFAULT_PARAMETER = 24
    }
    
    enum deviceIDType : Byte{
        case UNKNOWN = 0x00
        case APSM = 0xAA
    }
    
    var head:Byte = 0x3F;
    var checksum:Byte = 0;
    var deviceID:Byte = deviceIDType.APSM.toRaw()
    var command:Byte = commandType.RADIO.toRaw()
    var len:Int16 = 0;
    
    init (deviceID:deviceIDType,command:commandType,len:Int16){
        self.deviceID = deviceID.toRaw()
        self.command = command.toRaw()
        self.len = len
    }
    
    init(){}
    
    func pack() -> NSMutableData!{
        var me = self
        var data = NSMutableData(bytes: &me , length: sizeof(devicePacketHeader))
        return data
    }
    
    mutating func unpack(data:NSData?){
        if data{
            var me = self
            data!.getBytes(&me, length: sizeof(devicePacketHeader))
            self = me
        }
    }
    
    func packetCommandType() -> commandType?{
        return commandType.fromRaw(command)
    }
}

//MARK: Sender

class packetFactory{
    class func sender<T where T:Constructible, T:Packable>(command:devicePacketHeader.commandType,content:T) -> devicePacketSender<T>?{
        var header:devicePacketHeader
        
        switch (command,content){
        case (.ASK_DEVICE,let TAsk) where TAsk is devicePacketNil:
            header = devicePacketHeader(deviceID: .UNKNOWN, command: command, len:Int16(sizeof(T)))
            
        case (.ASK_VERSION,_),(.RADIO,_),(.READ_PARAMETERS,_),(.DEFAULT_PARAMETER,_) where content is devicePacketNil:
            fallthrough
        case (.SAVE_PARAMETERS, _) where content is devicePacketParameters:
            fallthrough
        case (.UPDATE_PARAMETER, _) where content is devicePacketParameters:
            header = devicePacketHeader(deviceID: .APSM, command: command, len:Int16(sizeof(T)))
            
        default:
            return nil
        }
        
        return devicePacketSender(deviceHeader: header, deviceContent: content)
    }
    
}

struct devicePacketSender <T where T:Constructible, T:Packable> {
    var deviceHeader:devicePacketHeader = devicePacketHeader();
    var deviceContent: T = T()
    
    func pack() -> NSData!{
        let headerData = deviceHeader.pack()
        let contentData = deviceContent.pack()
        var totalData = headerData
        totalData.appendData(contentData)
        
        return totalData
    }
    
    func computeChecksum() -> Byte?{
        var data = pack()
        
        if data.length != sizeof(devicePacketHeader) + sizeof(T){
            return nil
        }
        
        var sum:Byte = 0x21
        var aByte:Byte = 0
        
        for index in 2..<data.length{
            data.getBytes(&aByte, range: NSMakeRange(index, 1))
            sum ^= aByte
        }
        
        return sum
    }
}

struct devicePacketNil:Constructible, Packable{
    //    init
    func pack() -> NSMutableData!{
        var me = self
        var data = NSMutableData(bytes: &me , length: sizeof(devicePacketNil))
        println(data)
        return data
    }
}

struct devicePacketSingleParameter:Constructible, Packable{
    var index:Float = 20
    var value:Float = 21
    
    init(index:Float,value:Float){
        self.index = index
        self.value = value
    }
    
    init() {}
    
    func pack() -> NSMutableData!{
        var me = self
        var data = NSMutableData(bytes: &me , length: sizeof(devicePacketSingleParameter))
        println(data)
        return data
    }
}

//MARK: Receiver

struct devicePacketReceiver <T where T:Constructible, T:Unpackable> {
    var deviceHeader:devicePacketHeader = devicePacketHeader();
    var deviceContent: T = T()
    
    //    func computeChecksum() -> Byte{
    //        var data = pack()
    //
    //        if data.length == 0{
    //            return 0
    //        }
    //
    //        var sum:Byte = 0x21
    //        let PACKET_HEADER_HEAD:Byte = 0x3F
    //        sum ^= PACKET_HEADER_HEAD
    //        var aByte:Byte = 0
    //
    //        for index in 0..<data.length{
    //            data.getBytes(&aByte, range: NSMakeRange(index, 1))
    //            sum ^= aByte
    //        }
    //
    //        return sum
    //    }
    mutating func unpack(data:NSData?) -> Bool{
        if data{
            var deviceHeaderSize:Int = sizeof(devicePacketHeader)
            var deviceContentSize:Int = sizeof(T)
            
            if data!.length >= deviceHeaderSize + deviceContentSize{
                deviceHeader.unpack(data!.subdataWithRange(NSMakeRange(0, deviceHeaderSize)))
                deviceContent.unpack(data!.subdataWithRange(NSMakeRange(deviceHeaderSize, deviceContentSize)))
                return true
            }
        }
        return false
    }
    
    mutating func unpack123(data:NSData?) -> devicePacketReceiver<T>?{
//    mutating func unpack123(data:NSData?) -> Any?{
        if data{
            var deviceHeaderSize:Int = sizeof(devicePacketHeader)
            var deviceContentSize:Int = sizeof(T)
            
            if data!.length >= deviceHeaderSize + deviceContentSize{
                deviceHeader.unpack(data!.subdataWithRange(NSMakeRange(0, deviceHeaderSize)))
                deviceContent.unpack(data!.subdataWithRange(NSMakeRange(deviceHeaderSize, deviceContentSize)))
                var me = self
                return me
            }
        }
        return nil
    }
    
}

struct devicePacketAskDeviceID : Constructible, Unpackable{
    var revVersion:Int = 0xAA
    
    mutating func unpack(data:NSData?){
        if data{
            var me = self
            data!.getBytes(&me, length: sizeof(devicePacketAskDeviceID))
            self = me
        }
    }
}

struct devicePacketSetting:Constructible, Unpackable{
    var revVersion:UInt16 = 6
    var subVersion:UInt8 = 7
    var mainVersion:UInt8 = 8
    
    mutating func unpack(data:NSData?){
        if data{
            var me = self
            data!.getBytes(&me, length: sizeof(devicePacketSetting))
            self = me
        }
    }
}

struct devicePacketRadios:Constructible, Unpackable{
    var  Aileron:Float = 10;
    var  Elevator:Float = 11;
    var  Throttle:Float = 12;
    var  Rudder:Float = 13;
    var  Gear_Mode:Float = 14;
    var  Pitch_Return_Home:Float = 15;
    var  Aux1_Smart:Float = 16;
    var  Aux2:Float = 17;
    
    mutating func unpack(data:NSData?){
        if data{
            var me = self
            data!.getBytes(&me, length: sizeof(devicePacketRadios))
            self = me
        }
    }
}

struct devicePacketAck:Constructible, Unpackable{
    var ack:Byte = 30
    
    mutating func unpack(data:NSData?){
        if data{
            var me = self
            data!.getBytes(&me, length: sizeof(devicePacketAck))
            self = me
        }
    }
}

//MARK: Common (Sender & Receiver)

struct devicePacketParameters:Constructible, Packable, Unpackable{
    var multiRotorMode:Byte = 0;
    var CMDSource:Byte = 0;
    var SPK_Binding:Byte = 0;
    var p:Byte = 0;
    var q:Byte = 0;
    var r:Byte = 0;
    var phi:Byte = 0;
    var theta:Byte = 0;
    var psi:Byte = 0;
    var altitude:Byte = 0;
    var AntX:Byte = 0;
    var AntY:Byte = 0;
    var AntZ:Byte = 0;
    var LPLevel1_Enable:Byte = 0;
    var LPLevel1_Voltage:Byte = 0;
    var LPLevel2_Enable:Byte = 0;
    var LPLevel2_Voltage:Byte = 0;
    var AilDir:Byte = 0;
    var EleDir:Byte = 0;
    var ThrDir:Byte = 0;
    var RudDir:Byte = 0;
    var OSD_Unit:Byte = 0;
    var OSD_VideoFormat:Byte = 0;
    var OSD_VoltageEnable:Byte = 0;
    var OSD_VoltageWarning:Byte = 0;
    var OSD_DistanceEnable:Byte = 0;
    var OSD_DistanceWarning:Byte = 0;
    var OSD_HeightEnable:Byte = 0;
    var OSD_HeightHWarning:Byte = 0;
    var OSD_HeightLWarning:Byte = 0;
    var OSD_SatelliteEnable:Byte = 0;
    var OSD_SatelliteWarning:Byte = 0;
    var OSD_VisionAngle:Byte = 0;
    var OSD_ScreenHOffSet:Byte = 0;
    var OSD_ScreenVOffSet:Byte = 0;
    var OSD_ShowPosition:Byte = 0;
    var FlightMode:Byte = 0;
    
    func pack() -> NSMutableData!{
        var me = self
        var data = NSMutableData(bytes: &me , length: sizeof(devicePacketAck))
        return data
    }
    
    mutating func unpack(data:NSData?){
        if data{
            var me = self
            data!.getBytes(&me, length: sizeof(devicePacketParameters))
            self = me
        }
    }
}