Controller.h

Go to the documentation of this file.

// Copyright (C) Sven Rosvall (sven@rosvall.ie)
// This file is part of VLCB-Arduino project on https://github.com/SvenRosvall/VLCB-Arduino
// Licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.
// The full licence can be found at: http://creativecommons.org/licenses/by-nc-sa/4.0/
 
#pragma once
 
#ifndef DEBUG_SERIAL
#define DEBUG_SERIAL Serial
#endif
 
#include "initializer_list.h"
#include "ArrayHolder.h"
#include "CircularBuffer.h"
#include "Configuration.h"
#include "TimedResponse.h"
 
namespace VLCB
{
 
// Size of the action queue. 
// Testing shows that the queue often gets up to 4 elements.
// Set size to 8 to be on the safe side.
const int ACTION_QUEUE_SIZE = 8;

struct VlcbMessage
{
  uint8_t len; // Value 0-7 or FF for messages handled in CanTransport
  uint8_t data[8];
  
  VlcbMessage() = default;
  
  VlcbMessage(uint8_t len, uint8_t data[])
    : len(len)
  {
    memcpy(this->data, data, len);
  }

  explicit VlcbMessage(VlcbOpCodes opc)
    : len(1)
  {
    data[0] = opc;
  }
  
  VlcbMessage & addData(byte b);
  VlcbMessage & add2Bytes(unsigned int n);
  VlcbMessage & addNN(unsigned int nn) { return add2Bytes(nn); }
  VlcbMessage & addEN(unsigned int en) { return add2Bytes(en); }
  VlcbMessage & addNNEN(byte nn_en[EE_HASH_BYTES]);
};

enum ACTION : byte
{
  ACT_MESSAGE_IN,             
  ACT_MESSAGE_OUT,            
  ACT_START_CAN_ENUMERATION,  
  ACT_CHANGE_MODE,            
  ACT_RENEGOTIATE,            
  ACT_INDICATE_ACTIVITY,      
  ACT_INDICATE_WORK,          
  ACT_INDICATE_MODE,          
  // ...
};

struct Action
{
  enum ACTION actionType; 
  union                   
  {
    VlcbMessage vlcbMessage; 
    bool fromENUM;           
    VlcbModeParams mode;     
  };
 
  Action() = default;
 
  Action(ACTION type)
    : actionType(type)
    , fromENUM(false) // Must include one item from the union.
  {}
 
  Action(ACTION type, bool fromENUM)
    : actionType(type), fromENUM(fromENUM)
  {}
 
  Action(ACTION type, const VlcbMessage & msg)
    : actionType(type), vlcbMessage(msg)
  {}
 
  Action(ACTION type, VlcbModeParams mode)
    : actionType(type), mode(mode)
  {}
};
 
class Service;
 
//
//
class Controller
{
public:
//  Controller();
  explicit Controller(Configuration *conf);
//  Controller(std::initializer_list<Service *> services);
  Controller(Configuration *conf, std::initializer_list<Service *> services);
  
  void setServices(std::initializer_list<Service *> services);
 
  Configuration * getModuleConfig() const { return module_config; }
 
  void setName(const char *mname) { module_config->setName(mname); }
 
  const ArrayHolder<Service *> & getServices() { return services; }
 
  void updateParamFlags();
  void setParamFlag(VlcbParamFlags flag, bool set);
  Parameters & getParams() { return module_config->getParams(); }
  unsigned char getParam(VlcbParams param) const { return module_config->getParam(param); }
 
  bool sendMessage(const VlcbMessage &msg); 
  bool sendMessage(const VlcbMessage *msg); 
 
  void begin();
  bool sendMessageWithNN(VlcbOpCodes opc);
  bool sendMessageWithNN(VlcbOpCodes opc, byte b1);
  bool sendMessageWithNN(VlcbOpCodes opc, byte b1, byte b2);
  bool sendMessageWithNN(VlcbOpCodes opc, byte b1, byte b2, byte b3);
  bool sendMessageWithNN(VlcbOpCodes opc, byte b1, byte b2, byte b3, byte b4);
  bool sendMessageWithNN(VlcbOpCodes opc, byte b1, byte b2, byte b3, byte b4, byte b5);
  bool sendWRACK();
  bool sendCMDERR(byte cerrno);
  void sendGRSP(VlcbOpCodes opCode, byte serviceType, byte errCode);
  void sendDGN(byte serviceIndex, byte diagCode, unsigned int counter);
 
  byte getModuleCANID() const { return module_config->CANID; }
  void process();
  void indicateMode(VlcbModeParams mode);
  void indicateActivity();
  
  void putAction(const Action & action);
  void putAction(ACTION action);
  bool pendingAction();
  bool pendingTasks();
 
  void messageActedOn();
  unsigned int getMessagesActedOn() { return diagMsgsActed; }
  
  const CircularBuffer<Action, ACTION_QUEUE_SIZE> & getActionQueue() const { return actionQueue; }
 
  void addTimedResponseTask(TimedResponse::Task * task);
 
private:
  Configuration *module_config;
  ArrayHolder<Service *> services;
 
  CircularBuffer<Action, ACTION_QUEUE_SIZE> actionQueue;
  TimedResponse timedResponses;
 
  // Really an MNS diagnostic but placed here as its data is collected across all services.
  unsigned int diagMsgsActed = 0;
};
 
}