main.c

#define _GNU_SOURCE
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>

#define VERSION "0.0.1"
#define LOG_LEVEL LOG_NONE

#include <phev.h>
#include "phevargs.h"
#include "msg_utils.h"
#ifdef MQTT_PAHO
#include "msg_mqtt_paho.h"
#endif

char *remaining_args = NULL, num_remaining_args = 0;

bool bool_value;
uint8_t uint_value;

int wait_for_regs = 0;

static void operationCallback(phevCtx_t *ctx, void *value)
{
    phev_args_opts_t *opts = (phev_args_opts_t *)phev_getUserCtx(ctx);
    if (!opts->numerical)
    {
        printf("Operation successful\n");
    }
    else
    {
        printf("0");
    }
    phev_exit(ctx);
    exit(0);
}
static void operationCallbackNoExit(phevCtx_t *ctx, void *value)
{ 
    phev_args_opts_t *opts = (phev_args_opts_t *)phev_getUserCtx(ctx);
    if (!opts->numerical)
    {
        printf("Operation successful\n");
    }
    else
    {
        printf("0");
    }
}

static int main_eventHandler(phevEvent_t *event)
{
    phevCtx_t *ctx = event->ctx;

    phev_args_opts_t *opts = (phev_args_opts_t *)phev_getUserCtx(ctx);

    switch (event->type)
    {
    case PHEV_REGISTER_UPDATE:
    {   
        if (opts->verbose)
        {
          printf("Register %02X\n",event->reg);
          for (int i = 0; i < event->length; i++)
         
         {
              printf("%02X ", event->data[i]);
          }
          printf("\n");
          if (event->reg == KO_WF_DATE_INFO_SYNC_EVR)
          {
              printf("Date sync 20%d-%d-%d %d:%0d:%0d\n", event->data[0], event->data[1], event->data[2], event->data[3], event->data[4], event->data[5]);
          }
        }
        switch (opts->command)
        {
        default:
          break;
        case CMD_BATTERY:
        {
            if (event->reg == KO_WF_BATT_LEVEL_INFO_REP_EVR)
            {
                int batt = phev_batteryLevel(ctx);
                if (batt < 0)
                {
                    return 0;
                }
                if (opts->numerical)
                {
                    printf("%d", batt);
                }
                else {
                    printf("Battery level %d\n", batt);
                }
                
                exit(0);
            }
            break;
        }
        case CMD_ISLOCKED:
        {
            if (event->reg == KO_WF_DOOR_STATUS_INFO_REP_EVR)
            {
                int islocked = phev_isLocked(ctx);
                if (islocked < 0 && !opts->numerical)
                {
                    printf("Doors in UNKNOWN STATE\n");
                } 
                else if (islocked < 0 && opts->numerical)
                {
                    printf("-1");
                } 
                else if (islocked == 1 && !opts->numerical)
                {
                    printf("Doors are Locked\n");
                }
                else if (islocked == 1 && opts->numerical)
                {
                    printf("1");
                }
                else if (islocked == 0 && !opts->numerical)
                {   
                    printf("Doors are UnLocked\n");
                }
                else
                {
                    printf("0");
                }
                exit(0);
            }
            break;
        }
        case CMD_CHARGING_STATUS:
        {
            if (event->reg == KO_WF_OBCHG_OK_ON_INFO_REP_EVR)
            {
                int chargeStatus = phev_chargingStatus(ctx);
                if (chargeStatus < 0)
                {
                    return 0;
                }
                if (chargeStatus == 1 && !opts->numerical)
                {
                    printf("Charging\n");
                } 
                else if (chargeStatus == 1 && opts->numerical) 
                {
                    printf("1");
                }
                else if (chargeStatus == 0 && opts->numerical)
                {
                    printf("0");
                }
                else {
                   printf("Not charging\n");
                 }
                exit(0);
            }
            break;
        }
        case CMD_HVAC_STATUS:
        {
            if (event->reg == KO_WF_TM_AC_STAT_INFO_REP_EVR)
            {
                printf("HVAC Status\n");
                phevServiceHVAC_t * ph =  phev_HVACStatus(ctx);
                printf("Operating:%d\n", ph->operating);
                printf("mode:%d\n", ph->mode);
                exit(0);
            }
            break;
        }
        case CMD_HVAC_STATUS_OPERATING:
        {
            if (event->reg == KO_WF_TM_AC_STAT_INFO_REP_EVR)
            {
                phevServiceHVAC_t * ph =  phev_HVACStatus(ctx);
                if (!opts->numerical)
                {
                    printf("HVAC Status Operating\n");
                    printf("Operating:%d\n", ph->operating);
                }
                else 
                {
                    printf("%d", ph->operating);
                } 
                exit(0);
            }
            break;
        }
        case CMD_HVAC_STATUS_MODE:
        {
            if (event->reg == KO_WF_TM_AC_STAT_INFO_REP_EVR)
            {
                phevServiceHVAC_t * ph =  phev_HVACStatus(ctx);
                if (!opts->numerical)
                {
                    printf("HVAC Status Mode\n");
                    printf("mode:%d\n", ph->mode);
                }
                else 
                {
                    printf("%d", ph->mode);
                }
                exit(0);
            }
            break;
        }
        case CMD_REMAINING_CHARGING_STATUS:
        {
            if (event->reg == KO_WF_OBCHG_OK_ON_INFO_REP_EVR)
            {
                int remainingChargeStatus = phev_remainingChargeTime(ctx);
                if (remainingChargeStatus < 0)
                {
                    return 0;
                }
                if (!opts->numerical)
                {
                    printf("Remaining %d\n", remainingChargeStatus);
                }
                else 
                {
                    printf("%d", remainingChargeStatus);
                }
                exit(0);
            }
            break;
        }
        case CMD_DISPLAY_REG:
        {
            printf("Register : %d Data :", event->reg);
            for (int i = 0; i < event->length; i++)
            {
                printf("%02X ", event->data[i]);
            }
            printf("\n");
            break;
        }
        case CMD_GET_REG_VAL:
        {
            phevData_t *reg = phev_getRegister(ctx, opts->reg_operand);
            if (reg == NULL)
            {
                if (wait_for_regs > WAIT_FOR_REG_MAX)
                {
                    printf("REGISTER TIMEOUT\n");
                    exit(0);
                }
                wait_for_regs++;
                return 0;
            }
            if (!opts->numerical)
            {
                printf("Get register %d : ", opts->reg_operand);
            }
            
            for (int i = 0; i < reg->length; i++)
            {
                printf("%02X ", reg->data[i]);
            }
            printf("\n");
            exit(0);
            break;
        }
        }
        return 0;
    }

    case PHEV_REGISTRATION_COMPLETE:
    {
        printf("Registration Complete\n");
        exit(0);
    }
    case PHEV_CONNECTED:
    {
        return 0;
    }
    case PHEV_STARTED:
    {
        printf("Connected to car successfully\n");
        return 0;
    }
    case PHEV_VIN:
    {
        if (opts->verbose)
        {
            printf("VIN number : %s\n", event->data);
        }
        if (opts->command != CMD_UNSET && opts->command != CMD_INVALID)
        {
            switch (opts->command)
            {
            case CMD_HEADLIGHTS:
            {
                if (!opts->numerical)
                {
                    printf("Turning %s headlights\n", opts->operand_on ? "ON" : "OFF");    
                }
                phev_headLights(event->ctx, opts->operand_on, operationCallback);
                break;
            }
            case CMD_PARKING_LIGHTS:
            {
                if (!opts->numerical)
                {
                    printf("Turning %s parking lights\n", opts->operand_on ? "ON" : "OFF");    
                }
                phev_parkingLights(event->ctx, opts->operand_on, operationCallback);
                break;
            }
            case CMD_AIRCON:
            {
                if (!opts->numerical)
                {
                    printf("Turning air conditioning %s\n", opts->operand_on ? "ON" : "OFF");
                }
                phev_airCon(event->ctx, opts->operand_on, operationCallback);
                break;
            }
            case CMD_UPDATE:
            {
                if (!opts->numerical)
                {
                    printf("Update All\n");    
                }
                phev_updateAll(event->ctx, operationCallback);
                break;
            }
            case CMD_AIRCON_MODE:
            {
                if (!opts->numerical)
                {
                    printf("Switching air conditioning mode to %d for %d mins\n", opts->operand_mode, opts->operand_time);    
                }
                if (opts->verbose)
                {
                    printf("Car Model: %d\n", opts->carModel);
                }
                if ( opts->carModel == 2019){
                    phev_airConMY19(event->ctx, opts->operand_mode, opts->operand_time, operationCallback);
                } else {
                    phev_airConMode(event->ctx, opts->operand_mode, opts->operand_time, operationCallback);
                }

                break;
            }
            default:
            break;
            }
        }
        return 0;
    }
    case PHEV_ECU_VERSION:
    {
        if (!opts->numerical)
                {
                    
                }
        if (opts->verbose)
        {
            printf("ECU Version : %s\n", event->data);
        }
        return 0;
    }
    case PHEV_REGISTER_UPDATE_ACK:
        if(opts->verbose)
        {
            printf("Register %d Acknowledged\n",event->reg);
        }
        return 0;
    default:
        break;
    }

    return 0;
}

void *main_thread(void *ctx)
{
    phev_start((phevCtx_t *)ctx);
    return NULL;
}
void print_intro()
{
    printf("Mitsubishi Outlander PHEV Remote CLI - ");
    printf("Designed and coded by Jamie Nuttall 2020\nMIT License\n");
    //printf("Type 'x' then enter to quit.\n");
    printf("Wait...\n");
}

int main(int argc, char *argv[])
{
    phevCtx_t *ctx = NULL;

    phev_args_opts_t *opts = phev_args_parse(argc, argv);

    if (opts == NULL)
    {
        printf("ERROR Options could not be parsed");
        exit(1);
    }
    if (opts->error)
    {
        printf("ERROR %s\n", opts->error_message);
        exit(1);
    }
    
    phevSettings_t settings = {
        .host = opts->host,
        .mac = opts->mac,
        .port = opts->port,
        .numerical = opts->numerical,       
        .registerDevice = (opts->command == CMD_REGISTER ? true : false),
        .handler = main_eventHandler,
        .ctx = (void *)opts,
    };

    if (!opts->numerical)
    {
        print_intro();
    }

    if (opts->command == CMD_REGISTER)
    {
        printf("Registering device\n");
        printf("Host : %s\nPort : %d\nMAC : %02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx\n", opts->host, opts->port, opts->mac[0], opts->mac[1], opts->mac[2], opts->mac[3], opts->mac[4], opts->mac[5]);
        ctx = phev_registerDevice(settings);
    }
    else
    {
        if (opts->verbose)
        {
            printf("Host : %s\nPort : %d\nMAC : %02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx\n", opts->host, opts->port, opts->mac[0], opts->mac[1], opts->mac[2], opts->mac[3], opts->mac[4], opts->mac[5]);
        }
        ctx = phev_init(settings);
    }

    pthread_t main;

    if (opts->command == CMD_UNSET)
    {
        printf("No command exiting.\n");
        exit(0);
    }
    if (opts->command == CMD_INVALID)
    {
        printf("Error %s.\n", opts->error_message);
        exit(0);
    }
    int ret = pthread_create(&main, NULL, main_thread, (void *)ctx);
    //main_thread((void *) ctx);
    char ch;
    do
    {
        ch = getchar();

        switch(ch)
        {
        case 'r':
        {
            printf("Disconnecting\n");
            phev_disconnect(ctx);
            break;
        }
        case 'l':
        {
            printf("Lights on\n");
            phev_headLights(ctx,true,operationCallbackNoExit);
            break;
        }
        case 'a':
        {
            printf("Aircon on\n");
            phev_airCon(ctx, true, operationCallbackNoExit);
        }
        }

    } while (ch != 'x' && phev_running(ctx));

    phev_disconnect(ctx);

    printf("Exiting\n");
    exit(0);
}