aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Android_Studio/Tango.Integration/build.gradle
blob: ba8a3f6639127560fa8ee53cc01f9260db9816bd (plain) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

apply plugin: 'com.android.library'

android {
    compileSdkVersion 26
    buildToolsVersion "26.0.1"


    defaultConfig {
        minSdkVersion 22
        targetSdkVersion 26
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"

    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }

    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }

    dexOptions {
        preDexLibraries = false
    }
}

dependencies {
    implementation fileTree(include: ['*.jar'], dir: 'libs')
    implementation 'com.android.support:appcompat-v7:26.1.0'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'com.android.support.test:runner:1.0.1'
    androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.1'
    compile globalDependencies.rxJavaAndroid
    compile globalDependencies.rxJava
    compile globalDependencies.dagger
    compile globalDependencies.daggerAndroid
    implementation project(':Tango.PMR')
    implementation project(':Tango.Transport')
    implementation project(':Tango.Core')
    implementation project(':Tango.DAL')
    implementation project(':Tango.Web')
    implementation project(':Tango.Logging')
}
generated by cgit v1.3.1 (git 2.54.0) at 2026-07-25 16:30:39 +0000
/************************************************************************************************************************
 * buttons.c
 * buttons behaver
 *
************************************************************************************************************************/
#include <Container.h>
#include <DataDef.h>
#include "include.h"

#include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"//#include "FPGA_GPIO.h"  //  use for FPGA IO
#include "DataDef.h"  //  use for FPGA IO
#include "Modules/Control/control.h" //  use for FPGA IO
#include "Modules/General/buttons.h"
#include "StateMachines/Printing/PrintingSTM.h"
#include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"

#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <driverlib/gpio.h>
#include "Common/report/report.h"
#include "Modules/Thread/Thread_ex.h"

#include "Modules/General/buttons.h"
#include "StateMachines/Initialization/PowerOffSequence.h"
#include "StateMachines/Initialization/PowerIdle.h"

int PowerDown();
int PowerUp();
int thredJog();



//enum PBstat OnOffPBstate = OFFPB;
//enum PBstat ret
//enum PBstat threadPB = OFFPB;



button power, jog, load, cart1, cart2, cart3;
uint32_t ButtonPowerCallBackFunction(uint32_t IfIndex, uint32_t ReadValue);
uint32_t ButtonPowerCBFunction(uint32_t IfIndex, uint32_t ReadValue);
uint32_t ShortLongOffPB(uint8_t OnOffPB,  button *pBtn);
uint32_t StateMachine( button *pBtn);


uint32_t ButtonJogCallBackFunction(uint32_t IfIndex, uint32_t ReadValue);
uint32_t ButtonJogCBFunction(uint32_t IfIndex, uint32_t ReadValue);
uint8_t  thraedJogging(uint8_t off);
//uint32_t setJoggingEnableCondition( button *pBtn);
uint32_t joggingMachine(  button *pBtn);    //uint8_t OnOffPB,


uint32_t ButtonLoadCallBackFunction(uint32_t IfIndex, uint32_t ReadValue);
uint32_t ButtonLoadCBFunction(uint32_t IfIndex, uint32_t ReadValue);
uint32_t LoadStatMachine( button *pBtn);


/*
void Power_Reset();
uint8_t Buttons_LEDS(BUTTON Button, OPERATION_MODE LED_Mode);
uint8_t Buzzer(OPERATION_MODE Buzzer_Mode);
bool Read_PWR_Button();//TODO move to GPIO folder
*/


int PowerDown()
{
    bool ret = !OK;
    ret = PowerOffInit();

    return ret;
}

int PowerUp()
{
    bool ret = OK;

    return ret;
}

bool SetPowerMachineState(PBmachineState state)
{
    bool ret = OK;
    switch ( state )
    {
        case sttOFF:
        case sttON:
        case sttIDLE:
            power.state = state;
           break;
        case sttDISABLE:
        case sttENABLE:
        case sttJOGGING:
            jog.state = state;
            break;
        case sttRDY:
        case sttPRELOAD:
        case sttLOADING:
        case sttLOADSUCSESS:
        case sttLOADFAIL:
            load.state = state;
            break;
        default:
              break;
    }


    return ret;
}
/*
 * read GPIO status
 * port: GPIO_PORTN_BASE
 * pin : GPIO_PIN_7
 *
 * return !GPIOstatus
 */
uint32_t ButtonPowerCallBackFunction(uint32_t IfIndex, uint32_t ReadValue)
{
   return Read_PWR_Button();
   /*
    *
     if(ROM_GPIOPinRead(GPIO_PORTN_BASE, GPIO_PIN_7))
       return 0x00;
   else
       return 0x01;
    */
}
uint32_t ButtonJogCallBackFunction(uint32_t IfIndex, uint32_t ReadValue)
{
    return Get_Thread_Jogging_Button();
//
//    if(ROM_GPIOPinRead(GPIO_PORTN_BASE, GPIO_PIN_7))
//       return 0x00;
//   else
//       return 0x01;
}

uint32_t ButtonLoadCallBackFunction(uint32_t IfIndex, uint32_t ReadValue)
{
    return Get_Thread_Load_Button();
//    if(ROM_GPIOPinRead(GPIO_PORTN_BASE, GPIO_PIN_7))
//       return 0x00;
//   else
//       return 0x01;
}

//uint32_t    AddControlCallback( ControlCBFunction Callback, CTRL_TIMING_ENUM CtrlFrequency, DataReadCBFunction DriverfPtr, uint16_t IfIndex, uint32_t Parameter1, uint32_t Parameter2 );
//Power_Reset()// Resets the MCU

#define BUTTOMS_SAMPLE_TIME 50

uint32_t Buttons_Init(void)
{
    strcpy(power.bttn_name, "power");
    power.bttn_status = release;    // 0=release 1=press
    power.Action = OFFPB ;   //off,short,long,count,replong
    power.color = colorON;   //off, blue, blink, bithing
    power.state = sttON; //sttOFF, sttON, sttDISABLE, sttENABLE, sttIDLE, sttJOGGING
    power.count = 0;

    AddControlCallback( ButtonPowerCBFunction, BUTTOMS_SAMPLE_TIME, ButtonPowerCallBackFunction, 0,0,0 ); // eFiftyMillisecond

    strcpy(jog.bttn_name, "jog");
    jog.bttn_status = release;    // 0=release 1=press
    jog.Action = OFFPB ;   //OFFPB,short,long,count,replong
    jog.color = colorON;   //colorOFF, BLUE, BLINK,
    jog.state = sttENABLE; // sttDISABLE, sttENABLE, sttJOGGING
    jog.count = 0;

    AddControlCallback( ButtonJogCBFunction, BUTTOMS_SAMPLE_TIME, ButtonJogCallBackFunction, 0,0,0 ); //

    strcpy(load.bttn_name, "load");
    load.bttn_status = release;    // 0=release 1=press
    load.Action = OFFPB ;   //OFFPB,short,long,count,replong
    load.color = colorOFF;   //colorOFF, BLUE, BLINK,
    load.state = sttRDY; //
    load.count = 0;

    AddControlCallback( ButtonLoadCBFunction, BUTTOMS_SAMPLE_TIME, ButtonLoadCallBackFunction, 0,0,0 ); //
return OK;
}


//read the buttons data here and handle
uint32_t ButtonPowerCBFunction(uint32_t IfIndex, uint32_t ReadValue)
{
    ShortLongOffPB(ReadValue,&power);
    return 0;
}

uint32_t ButtonJogCBFunction(uint32_t IfIndex, uint32_t ReadValue)
{
    jog.bttn_status = ReadValue;
    //if (ReadValue == press)
    {
        //setJoggingEnableCondition(&jog);
        joggingMachine(&jog);
    }
    return 0;
}


uint32_t ButtonLoadCBFunction(uint32_t IfIndex, uint32_t ReadValue)
{
    uint8_t parameter = 2;

    if ((load.bttn_status == release) && (ReadValue == press))
    {
        REPORT_MSG(parameter," ------------ Start thread loading empty function  ----------------- ");
        load.bttn_status = press;
        LoadStatMachine(&load);

    }
    else load.bttn_status = ReadValue;

    return 0;
}

/*---------------------------------------------------------------------------------*/



/* ---------------------------------------------------------
 * --- ShortLongOffPB(int OnOffPB, enum PBstat *ret) ----
 * input:   OnOffPB status(0(pressed) or 1(relesed)
 *
 * output:  offPB, countPB, shortPB, longPB, replongPB
 *
 * that func get :
 *  OnOffPB status (
 *                  0=release,
 *                  1=pressed
 *                  )
 *
 ------------------------------------------------------------*/




uint32_t ShortLongOffPB(uint8_t OnOffPB,  button *pBtn)
{
    uint8_t parameter = 0 ;  // why we need it!!!!


    pBtn->count += OnOffPB;
    switch( pBtn->Action )
    {
        case OFFPB: // last OnOffPBstate was OFF
            if( OnOffPB )
            {
                pBtn->Action = COUNTPB ;
                REPORT_MSG(parameter," ------------ Start count PB Power  ----------------- ");
            }
            break;
        case COUNTPB: // last OnOffPBstate was COUNTPB
            if (OnOffPB)
            {
                if( pBtn->count > 5 ) //5*50ms=250ms
                {
                    pBtn->Action =  SHORTPB ;
                    REPORT_MSG(parameter," ------------ Start count PB Power  ----------------- ");
                }
            }
            else
            {
                pBtn->Action =  OFFPB ;
                pBtn->count = 0;
            }
            break;
        case SHORTPB: // last OnOffPBstate was SHORTPB
             if (OnOffPB)
             {
                 if (pBtn->count > 100) //5000ms
                 {
                     pBtn->Action =  LONGPB ;
                     REPORT_MSG(parameter," ------------ Long PB Power  ----------------- ");
                     StateMachine(pBtn);
                     pBtn->count = 0;
                 }
             }
             else
             {
                 REPORT_MSG(parameter," ------------ Short PB Power  ----------------- ");
                 StateMachine(pBtn);
                 pBtn->count = 0;
                 pBtn->Action =  OFFPB ;
             };
             break;
        case LONGPB:
             if (OnOffPB)
             {
                 REPORT_MSG(parameter," ------------ Please release the PB  ----------------- ");
             }
             else
             {
                 pBtn->Action =  OFFPB ;
                 pBtn->count = 0;
             }
             break;
       default:
           break;
    }
    return 0;
}









/* --- StateMachine(enum PBstat PBAction) ----
 * input:
 *
 * output:  offPB, countPB, shortPB, longPB, replong
 *
 *
 */



uint32_t StateMachine( button *pBtn) //short press(=0)/long press(=1)
{
    uint8_t parameter = 1;
    Report(" ------------ StateMachine   state  action ----------------- ",__FILE__,__LINE__,pBtn->state,RpWarning,pBtn->Action,0);

    switch (pBtn->state)// sttON/sttOFF/sttIDLE
        {
            case sttON:
                switch (pBtn->Action)
                {
                    case LONGPB:    //Power Down
                        pBtn->state = sttOFF;
                        pBtn->color =  colorOFF;
                        Pannel_Leds(POWER_ON_OFF,MODE_OFF);//AVI+
                        PowerDown();
                        REPORT_MSG(parameter," ------------ Power state is OFF  ----------------- ");
                        break;
//                   case SHORTPB:   //idle ?????
//                        setMachineStatus = IDLE; // ????/
//                        break;
                    default:
                        break;
                }
               break;
            case sttOFF:
                switch (pBtn->Action)
                {
//                    case LONGPB:    //Idle?

//                        break;
                    case SHORTPB:   //powerup?
                         // to do ?
                        pBtn->state = sttON;
                        pBtn->color = colorON ;
                        Pannel_Leds(POWER_ON_OFF,MODE_ON);//AVI+
                        PowerUp();
                        REPORT_MSG(parameter," ------------ Power state is ON  ----------------- ");
                        break;
                    default:
                        break;
                }
               break;
            case sttIDLE:
                switch (pBtn->Action)
                {
                    case LONGPB:    //Power off from idle
                        pBtn->state = sttOFF;
                        pBtn->color =  colorOFF;
                        Pannel_Leds(POWER_ON_OFF,MODE_OFF);//AVI+
                        PowerDown();
                        Pannel_Leds(POWER_ON_OFF,MODE_OFF); //AVI+ - TODO option MODE_ON to stop Breathing and the led will turn off in power down
                        REPORT_MSG(parameter," ------------ Power state is OFF  ----------------- ");
                        break;
                    case SHORTPB:   //Wake up from idle
                        pBtn->state = sttON;
                        PowerUp();  // to do ?
                        Pannel_Leds(POWER_ON_OFF,MODE_ON); //AVI+
                        REPORT_MSG(parameter," ------------ Power state is ON  ----------------- ");
                        break;
                    default:
                        break;
                }
                break;
            default:
                break;
        }
return 0;
}





    /*-----------------------------------------------------------------------------------*/


 /* int rdJoggingEnableCondition()
 * read if we can enabl the thraed jogging
 *
 *  return 0 or 1
 *  disable OFF(0) - the machine is working now you cannot jogging the thread.
 *  enable ON(1) - joggin thread is enable
 */



//uint32_t    setJoggingEnableCondition( button *pBtn)
//{
//    uint8_t parameter = 3;
//
//    if (0
////         to do : what are the conditions for enable / disable
////            1.
////            2.
////            3.
////            ...
//            )
//        {
//            pBtn->state = sttDISABLE;
//            REPORT_MSG(parameter," ------------ Jogging : setJoggingEnableCondition  sttDISABLE  ----------------- ");
//            pBtn->color = colorOFF;
//            Pannel_Leds(THREAD_JOGGING, MODE_OFF); //AVI+
//        //    ThreadAbortJoggingFunc();
//        }
//
//    else
//    {
//        pBtn->state = sttENABLE;
////        REPORT_MSG(parameter," ------------ Jogging : setJoggingEnableCondition  sttENABLE  ----------------- ");
//        pBtn->color = BLUE;
//        Pannel_Leds(THREAD_JOGGING, MODE_ON); //AVI+
//        //ThreadJoggingFunc(40);
//    }
//
//return 0;
//}





/*int joggingMachine()
 * state machine for thread jogging button:
 * 1. OFF - when the machine is working
 * 2. blue - when the machin is not workig so we can jog thread
 * 3. blink - when pushing the jog thread button and jogigthread
 *
 */


uint32_t joggingMachine(  button *pBtn) //uint8_t OnOffPB,
{

    uint8_t parameter = 4;

    if (sttDISABLE == pBtn->state)
    {
        // jogging is disable
        REPORT_MSG(parameter," ------------joggingMachine: Jogging is Disable   ----------------- ");
        pBtn->Action = OFFPB;
        pBtn->color =  colorOFF;
        Pannel_Leds(THREAD_JOGGING,MODE_OFF);//AVI+
    }
    else
    {
        if ( (pBtn->Action != OFFPB) && (pBtn->bttn_status == release))
        {
            REPORT_MSG(parameter," ------------joggingMachine:  Jogging OnOffPB == 00----------------- ");
            REPORT_MSG(parameter," ------------joggingMachine: stop Jogging    ----------------- ");
            pBtn->Action = OFFPB;
            ThreadAbortJoggingFunc(); // to do!!!!
            pBtn->color =  colorON;
            Pannel_Leds(THREAD_JOGGING, MODE_ON);//AVI+
        }
        else if ((pBtn->Action == OFFPB) && (pBtn->bttn_status == press))
        {
            pBtn->Action = LONGPB;
            REPORT_MSG(parameter," ------------joggingMachine: Jogging OnOffPB == 1   ----------------- ");
            REPORT_MSG(parameter," ------------joggingMachine: start Jogging    ----------------- ");
            pBtn->color =  BLINK;
            ThreadJoggingFunc(40);
        }
//        if (pBtn->bttn_status == press)ThreadJoggingFunc(40);
//        else
//        {
//            pBtn->Action = OFFPB;
//            REPORT_MSG(parameter," ??????????????????? joggingMachine: start Jogging    ???????????????????");
//        }
    }



//        if (OnOffPB == release)
//        {
//            REPORT_MSG(parameter," ------------joggingMachine:  Jogging OnOffPB == 00----------------- ");
//            REPORT_MSG(parameter," ------------joggingMachine: stop Jogging    ----------------- ");
//            pBtn->Action = OFFPB;
//            ThreadAbortJoggingFunc(); // to do!!!!
//            pBtn->color =  BLUE;
//            Pannel_Leds(THREAD_JOGGING, MODE_ON);//AVI+
//        }
//        else
//        {
//            if (pBtn->Action == OFFPB)
//            {
//                pBtn->Action = LONGPB;
//                REPORT_MSG(parameter," ------------joggingMachine: Jogging OnOffPB == 1   ----------------- ");
//                REPORT_MSG(parameter," ------------joggingMachine: start Jogging    ----------------- ");
//                pBtn->color =  BLINK;
//                ThreadJoggingFunc(40);
//            }
//            else
//            {
//                REPORT_MSG(parameter," ??????????????????? joggingMachine: start Jogging    ???????????????????");
//            }
//
//        }
//    }
return 0;
}


/*------------------------------------------------------------------------------*/

/*------     THREAD LOAD/UNLOAD        ----------*/


uint32_t LoadStatMachine( button *pBtn)
{
    uint8_t parameter = 5;

    //REPORT_MSG(parameter," ------------ start loading    ----------------- ");
    Report(" ------------ start loading    ----------------- ",__FILE__,__LINE__,pBtn->state,RpWarning,pBtn->color,0);
    switch (pBtn->state)
    {
        case sttRDY :
            REPORT_MSG(parameter," ------------ load.state = sttRDY    ----------------- ");
/*            switch (pBtn->Action)
            {
                case (SHORTPB):
                case (LONGPB):
                case (REPLONGPB):
                    pBtn->state = sttPRELOAD;
                    pBtn->color =  BLINK;*/
                    if (ThreadLoadButton( THREAD_LOAD_INIT))
                    {
                        pBtn->state = sttPRELOAD ;    // to do
                        pBtn->color =  colorON;
                        Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
                    }
                    else
                    {
                       // pBtn->state = sttDISABLE ;
                        Pannel_Leds(THREAD_LOAD, MODE_OFF);//AVI+
                    }
                    /*break;
                default :
                    break;
            }*/
            break;
        case sttPRELOAD:
            REPORT_MSG(parameter," ------------ load.state = sttPRELOAD    ----------------- ");
            /*switch (pBtn->Action)
            {
                case (SHORTPB):
                case (LONGPB):
                case (REPLONGPB):
                    pBtn->color =  BLUE;
                    Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+*/
                    if (ThreadLoadButton( THREAD_LOAD_INITIAL_TENSION))
                    {
                        pBtn->state = sttRDY ;    // to do
                        pBtn->color =  colorON;
                        Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
                    }
                    else
                    {
                        //pBtn->state = sttLOADFAIL ;
                        pBtn->color = fastBILNK ;    // to do
                    }
                    /*break;
                default :
                    break;
            }*/
            break;
        case sttLOADING:
            REPORT_MSG(parameter," ------------ load.state = sttLOADING    ----------------- ");
            pBtn->color =  fastBILNK;
            Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
            if (ThreadLoadButton( THREAD_LOAD_END))
            {
                pBtn->state = sttRDY ;    // to do
                pBtn->color =  colorON;
                Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
            }
            else
            {
                pBtn->state = sttRDY ;    // to do
                //pBtn->state = sttLOADFAIL ;
                pBtn->color = fastBILNK ;    // to do
            }
            break;
//        case sttLOADSUCSESS ?????
//            break;
//        case sttLOADFAIL:    ?????
//            break;

        default: //sttDISABLE
            REPORT_MSG(parameter," ------------ load.state = default    ----------------- ");
            pBtn->state = sttRDY ;    // to do
            pBtn->color =  BREATHING;
            Pannel_Leds(THREAD_LOAD, MODE_OFF);//AVI+
            break;
    }
    return OK;
}

void Ink_Cart_Led()//temporary for ITMA
{
    if(Is_Cartridge_Present(CART_1) == true)
    {
        Pannel_Leds( CART_1,  MODE_ON);
    }
    else
    {
        Pannel_Leds( CART_1,  MODE_OFF);
    }
    if(Is_Cartridge_Present(CART_2) == true)
    {
        Pannel_Leds( CART_2,  MODE_ON);
    }
    else
    {
        Pannel_Leds( CART_2,  MODE_OFF);
    }
    if(Is_Cartridge_Present(CART_3) == true)
    {
        Pannel_Leds( CART_3,  MODE_ON);
    }
    else
    {
        Pannel_Leds( CART_3,  MODE_OFF);
    }
}

void test_avi()
{

    power.color = BLINK;
    //power.color = fastBILNK

    //Machine_Idle_Mode = true;

}