Кто любит RISC в жизни, заходим, не стесняемся.
Ответить

Re: Open source plc STM32F103RBT6 source code Mitsubishi PL

Вс ноя 04, 2018 15:11:22

что значит нет ?

вот он, работает перед глазами

да, всего 2000 шагов
да, регистров D всего 2000

да подвисает где-то

но ведь работает и впихнулось же

Re: Open source plc STM32F103RBT6 source code Mitsubishi PL

Вс ноя 04, 2018 15:56:03

imsushka писал(а):вот он, работает перед глазами
Только у вас, или у остальных тоже? :) :)))

Re: Open source plc STM32F103RBT6 source code Mitsubishi PL

Вс ноя 04, 2018 16:23:25

я думаю у dosikusа тоже работает

Re: Open source plc STM32F103RBT6 source code Mitsubishi PL

Пн ноя 05, 2018 16:44:23

список команд FX1/FX2/FX3

???() - не знаю что такое и есть ли оно
то что закоменченно - нету
остальное есть
XXXP() команды есть автоматом
пример :
case 0x0010: CJ(); break;
// case 0x1010: CJP(); break;

CJP() реализовано в CJ()

Код:
// ----------
//            case 0x0001: ???();                     break;

            case 0x0002: EOUT();                    break;
            case 0x0003: EBSET();                   break;
            case 0x0004: ERST();                    break;

            case 0x0005: EOUT();                    break;
            case 0x0006: EBSET();                   break;
            case 0x0007: ERST();                    break;

            case 0x0008: PLS();                     break;
            case 0x0009: PLF();                     break;

//            case 0x000A: ???();                     break;
//            case 0x000B: ???();                     break;

            case 0x000C: RST_T_C();                 break;
            case 0x000D: RST_D();                   break;

//            case 0x000E: ???();                     break;

            case 0x000F: goto all_end;
// ----------

// ----------
// DOC 6.2.1 - 6.2.7
// ----------
            case 0x0010: CJ();                      break;
//            case 0x1010: CJP();                     break;
            case 0x0012: CALL();                    break;
//            case 0x1012: CALLP();                   break;
            case 0x0014: SRET();                    break;

//            case 0x0016: IRET();                    break;
//            case 0x0018: EI();                      break;
//            case 0x001A: DI();                      break;

            case 0x001C: goto all_end;
           
//            case 0x001E: WDT();                     break;
//            case 0x0020: FOR();                     break;
//            case 0x0022: NEXT();                    break;
// ----------

// ----------
// DOC 6.3.1 - 6.3.10
// ----------
#ifdef USE_COMPARE_MOVE

            case 0x0024: CMP();                     break;
//            case 0X1024: CMPP();                    break;
#ifdef USE_DOUBLE
            case 0x0025: DCMP();                    break;
//            case 0X1025: DCMPP();                   break;
#endif

            case 0x0026: ZCP();                     break;
#ifdef USE_DOUBLE
            case 0x0027: DZCP();                    break;
#endif

            case 0x0028: MOV();                     break;
#ifdef USE_DOUBLE
            case 0x0029: DMOV();                    break;
#endif

            case 0x002A: SMOV();                    break;

            case 0x002C: CML();                     break;
#ifdef USE_DOUBLE
            case 0x002D: DCML();                    break;
#endif

            case 0x002E: BMOV();                    break;

            case 0x0030: FMOV();                    break;
#ifdef USE_DOUBLE
            case 0x0031: DFMOV();                   break;
#endif

            case 0x0032: XCH();                     break;
#ifdef USE_DOUBLE
            case 0x0033: DXCH();                    break;
#endif

            case 0x0034: BCD();                     break;
#ifdef USE_DOUBLE
            case 0x0035: DBCD();                    break;
#endif

            case 0x0036: BIN();                     break;
#ifdef USE_DOUBLE
            case 0x0037: DBIN();                    break;
#endif

#endif // USE_COMPARE_MOVE
// ----------

// ----------
#ifdef USE_ARIPH

            case 0x0038: ADD();                     break;
#ifdef USE_DOUBLE
            case 0x0039: DADD();                    break;
#endif
            case 0x003A: SUB();                     break;
#ifdef USE_DOUBLE
            case 0x003B: DSUB();                    break;
#endif

#ifdef USE_MULDIV
            case 0x003C: MUL();                     break;
  #ifdef USE_DOUBLE
            case 0x003D: DMUL();                    break;
  #endif
            case 0x003E: DIV();                     break;
  #ifdef USE_DOUBLE
            case 0x003F: DDIV();                    break;
  #endif
#endif
            case 0x0040: INC();                     break;
//            case 0x1040: INCP();                    break;
#ifdef USE_DOUBLE
            case 0x0041: DINC();                    break;
            case 0x1041: DINC_P();                   break; // ?????
#endif
            case 0x0042: DEC();                     break;
//            case 0x1042: DECP();                    break;
#ifdef USE_DOUBLE
            case 0x0043: DDEC();                    break;
#endif
            case 0x0044: WAND();                    break;
#ifdef USE_DOUBLE
            case 0x0045: DWAND();                   break;
#endif
            case 0x0046: WOR();                     break;
#ifdef USE_DOUBLE
            case 0x0047: DWOR();                    break;
#endif
            case 0x0048: WXOR();                    break;
#ifdef USE_DOUBLE
            case 0x0049: DWXOR();                   break;
#endif
            case 0x004A: NEG();                     break;
#ifdef USE_DOUBLE
            case 0x004B: DNEG();                    break;
#endif

#endif // USE_ARIPH
// ----------

// ----------
#ifdef USE_ROTATE

            case 0x004C: ROR();                     break;
  #ifdef USE_DOUBLE
            case 0x004D: DROR();                    break;
  #endif
            case 0x004E: ROL();                     break;
  #ifdef USE_DOUBLE
            case 0x004F: DROL();                    break;
  #endif
            case 0x0050: RCR();                     break;
  #ifdef USE_DOUBLE
            case 0x0051: DRCR();                    break;
  #endif
            case 0x0052: RCL();                     break;
  #ifdef USE_DOUBLE
            case 0x0053: DRCL();                    break;
  #endif

//            case 0x0054: SFTR();                    break;
//            case 0x0056: SFTL();                    break;
//            case 0x0058: WSFR();                    break;
//            case 0x005A: WSFL();                    break;
//            case 0x005C: SFWR();                    break;
//            case 0x005E: SFWL();                    break;

#endif // USE_ROTATE
// ----------

// ----------
            case 0x0060: ZRST();                    break;
            case 0x0062: DECO();                    break;
//            case 0x0064: ENCO();                    break;
//            case 0x0066: SUM();                     break;
  #ifdef USE_DOUBLE
//            case 0x0067: DSUM();                    break;
  #endif
//            case 0x0068: BON();                     break;
  #ifdef USE_DOUBLE
//            case 0x0069: DBON();                    break;
  #endif

            case 0x006A: MEAN();                    break;
  #ifdef USE_DOUBLE
//            case 0x006B: DMEAN();                   break;
  #endif
//            case 0x006C: ANS();                     break;
//            case 0x006E: ANR();                     break;

#ifdef USE_MULDIV
            case 0x0070: SQR();                     break;
  #ifdef USE_DOUBLE
            case 0x0071: DSQR();                    break;
  #endif
#endif // USE_MULDIV

#ifdef USE_FLOAT
            case 0x0072: FLT();                     break;
  #ifdef USE_DOUBLE
            case 0x0073: DFLT();                    break;
  #endif
#endif // USE_FLOAT
// ----------

// ----------
//            case 0x0074: REF();                     break;
            case 0x0076: REFF();                    break;
            case 0x0078: MTR();                     break;
#ifdef USE_DOUBLE
            case 0x007A: DHSCS();                   break;
//            case 0x007C: DHSCR();                   break;
//            case 0x007E: DHSZ();                    break;
#endif

//            case 0x0080: SPD();                     break;
#ifdef USE_DOUBLE
//            case 0x0081: DSPD();                    break;
#endif

//            case 0x0082: PLSY();                    break;
//            case 0x0084: PWM();                     break;
//            case 0x0086: PLSR();                    break;
// ----------

// ----------
//            case 0x0088: IST();                     break;
//            case 0x008A: SER();                     break;
#ifdef USE_DOUBLE
//            case 0x008B: DSER();                    break;
#endif
//            case 0x008C: ABSD();                    break;
#ifdef USE_DOUBLE
//            case 0x008D: DABSD();                   break;
#endif
//            case 0x008E: INCD();                    break;
//            case 0x0090: TTMR();                    break;
//            case 0x0092: STMR();                    break;
            case 0x0094: ALT();                     break;
//            case 0x0096: RAMP();                    break;
//            case 0x0098: ROTS();                    break;
//            case 0x009A: SORT();                    break;
// ----------

// ----------
#ifdef USE_SPECIAL
//            case 0x009C: TKY();                     break;
//            case 0x009E: HKY();                     break;
//            case 0x00A0: DSW();                     break;
//            case 0x00A2: SEGD();                    break;
//            case 0x00A4: SEGL();                    break;
//            case 0x00A6: ARWS();                    break;
//            case 0x00A8: ASC();                     break;
//            case 0x00AA: PR();                      break;

//            case 0x00AC: FROM();                    break;
//            case 0x00AE: TO();                      break;

//            case 0x00B0: RS();                      break;
//            case 0x00B2: PRUN();                    break;
//            case 0x00B4: ASCI();                    break;
//            case 0x00B6: HEX();                     break;
//            case 0x00B8: CCD();                     break;
//            case 0x00BA: VRRD();                    break;
//            case 0x00BC: VRSC();                    break;
//            case 0x00BE: RS2();                     break;

//            case 0x00C0: PID();                     break;

//            case 0x00C2: ZPUSH();                   break;
//            case 0x00C4: ZPOP();                    break;
#endif // USE_SPECIAL
// ----------

// ----------
//            case 0x00C6: ???();                    break;
//            case 0x00C8: ???();                    break;
//            case 0x00CA: ???();                    break;
//            case 0x00CC: ???();                    break;
//            case 0x00CE: ???();                    break;
//            case 0x00D0: ???();                    break;
//            case 0x00D2: ???();                    break;
//            case 0x00D4: ???();                    break;
//            case 0x00D6: ???();                    break;
//            case 0x00D8: ???();                    break;
//            case 0x00DA: ???();                    break;
//            case 0x00DC: ???();                    break;
//            case 0x00DE: ???();                    break;
//            case 0x00E0: ???();                    break;
//            case 0x00E2: ???();                    break;
//            case 0x00E4: ???();                    break;
//            case 0x00E6: ???();                    break;
//            case 0x00E8: ???();                    break;
//            case 0x00EA: ???();                    break;
//            case 0x00EC: ???();                    break;
// ----------

// ----------
#ifdef USE_FLOAT
            case 0x00ED: DECMP();                    break;
            case 0x00EE: DEZCP();                    break;

            case 0x00F1: DEMOV();                   break;
//            case 0x00F?: DESTR();                   break;
//            case 0x00F?: DEVAL();                   break;
//            case 0x00FD: DEBCD();                   break;
//            case 0x00FF: DEBIN();                   break;

            case 0x0101: DEADD();                   break;
            case 0x0103: DESUB();                   break;
  #ifdef USE_MULDIV
            case 0x0105: DEMUL();                   break;
            case 0x0107: DEDIV();                   break;
  #endif
//            case 0x0109: DEXP();                    break;
//            case 0x010B: DLOGE();                   break;
//            case 0x010D: DLOG10();                  break;
            case 0x010F: DESQR();                   break;
//            case 0x0111: DENEG();                   break;

            case 0x0112: INT();                     break;
  #ifdef USE_DOUBLE
            case 0x0113: DINT();                    break;
  #endif
            case 0x0115: DSIN();                    break;
            case 0x0117: DCOS();                    break;
            case 0x0119: DTAN();                    break;

//            case 0x011B: DASIN();                   break;
//            case 0x011D: DACOS();                   break;
//            case 0x011F: DATAN();                   break;
//            case 0x0121: DRAD();                    break;
//            case 0x0123: DDEG();                    break;
#endif // USE_FLOAT
// ----------

// ----------
//            case 0x012C: WSUM();                    break;
#ifdef USE_DOUBLE
//            case 0x0137: DWSUM();                   break;
#endif
//            case 0x012E: WTOB();                    break;
//            case 0x0130: BTOW();                    break;
//            case 0x0132: UNI();                     break;
//            case 0x0134: DIS();                     break;
            case 0x0136: SWAP();                    break;
#ifdef USE_DOUBLE
            case 0x0137: DSWAP();                   break;
#endif
//            case 0x0138: SORT2();                   break;
#ifdef USE_DOUBLE
//            case 0x0139: DSORT2();                  break;
#endif
// ----------

// ----------
//            case 0x013A: ???();                    break;
//            case 0x013C: ???();                    break;
//            case 0x013E: ???();                    break;
//            case 0x0140: ???();                    break;
//            case 0x0142: ???();                    break;
//            case 0x0144: ???();                    break;
//            case 0x0146: ???();                    break;
//            case 0x0148: ???();                    break;
//            case 0x014A: ???();                    break;
//            case 0x014C: ???();                    break;
//            case 0x014E: ???();                    break;
// ----------

// ----------
#ifdef USE_TIME
            case 0x0150: TCMP();                    break;
            case 0x0152: TZCP();                    break;
#ifdef USE_ARIPH
            case 0x0154: TADD();                    break;
            case 0x0156: TSUB();                    break;   
#endif
//            case 0x0158: HTOS();                    break;
//            case 0x015A: STOH();                    break;
            case 0x015C: TRD();                     break;
            case 0x015E: TWR();                     break;
//            case 0x0160: HOUR();                    break;
#endif // USE_TIME
// ----------

// ----------
            case 0x0164: GRY();                     break;
#ifdef USE_DOUBLE
            case 0x0165: DGRY();                    break;
#endif
            case 0x0166: GBIN();                    break;
#ifdef USE_DOUBLE
            case 0x0167: DGBIN();                   break;
#endif
//            case 0x0168: RD3A();                    break;
//            case 0x016A: WR3A();                    break;

// ----------
            case 0x01C2: ELD();                     break;
            case 0x01C3: ELDI();                    break;
            case 0x01C4: EAND();                    break;
            case 0x01C5: EANI();                    break;
            case 0x01C6: EOR();                     break;
            case 0x01C7: EORI();                    break;

            case 0x01CA: LDP();                     break;
            case 0x01CB: LDF();                     break;
            case 0x01CC: ANDP();                    break;
            case 0x01CD: ANDF();                    break;
            case 0x01CE: ORP();                     break;
            case 0x01CF: ORF();                     break;

// ----------
#ifdef USE_SPECIAL
            case 0x01D0: LD_EQU();                  break;
#ifdef USE_DOUBLE
            case 0x01D1: DLD_EQU();                 break;
#endif
            case 0x01D2: LD_GTR();                  break;
#ifdef USE_DOUBLE
            case 0x01D3: DLD_GTR();                 break;
#endif
            case 0x01D4: LD_LSS();                  break;
#ifdef USE_DOUBLE
            case 0x01D5: DLD_LSS();                 break;
#endif
            case 0x01D8: LD_NEQ();                  break;
#ifdef USE_DOUBLE
            case 0x01D9: DLD_NEQ();                 break;
#endif
            case 0x01DA: LD_LEQ();                  break;
#ifdef USE_DOUBLE
            case 0x01DB: DLD_LEQ();                 break;
#endif
            case 0x01DC: LD_GEQ();                  break;
#ifdef USE_DOUBLE
            case 0x01DD: DLD_GEQ();                 break;
#endif

            case 0x01E0: AND_EQU();                 break;
#ifdef USE_DOUBLE
            case 0x01E1: DAND_EQU();                break;
#endif
            case 0x01E2: AND_GTR();                 break;
#ifdef USE_DOUBLE
            case 0x01E3: DAND_GTR();                break;
#endif
            case 0x01E4: AND_LSS();                 break;
#ifdef USE_DOUBLE
            case 0x01E5: DAND_LSS();                break;
#endif
            case 0x01E8: AND_NEQ();                 break;
#ifdef USE_DOUBLE
            case 0x01E9: DAND_NEQ();                break;
#endif
            case 0x01EA: AND_LEQ();                 break;
#ifdef USE_DOUBLE
            case 0x01EB: DAND_LEQ();                break;
#endif
            case 0x01EC: AND_GEQ();                 break;
#ifdef USE_DOUBLE
            case 0x01ED: DAND_GEQ();                break;
#endif

            case 0x01F0: OR_EQU();                  break;
#ifdef USE_DOUBLE
            case 0x01F1: DOR_EQU();                 break;
#endif
            case 0x01F2: OR_GTR();                  break;
#ifdef USE_DOUBLE
            case 0x01F3: DOR_GTR();                 break;
#endif
            case 0x01F4: OR_LSS();                  break;
#ifdef USE_DOUBLE
            case 0x01F5: DOR_LSS();                 break;
#endif
            case 0x01F8: OR_NEQ();                  break;
#ifdef USE_DOUBLE
            case 0x01F9: DOR_NEQ();                 break;
#endif
            case 0x01FA: OR_LEQ();                  break;
#ifdef USE_DOUBLE
            case 0x01FB: DOR_LEQ();                 break;
#endif
            case 0x01FC: OR_GEQ();                  break;
#ifdef USE_DOUBLE
            case 0x01FD: DOR_GEQ();                 break;
#endif

#endif // USE_SPECIAL
// ----------

            case 0XF7FF: RET();                     break;

Re: Open source plc STM32F103RBT6 source code Mitsubishi PL

Пн ноя 05, 2018 19:02:38

imsushka писал(а):я думаю у dosikusа тоже работает
Вот и переписывайтесь с ним через личку. :) Какой смысл на форуме писать, если в открытый доступ исходники не выкладываете? :dont_know:

Re: Open source plc STM32F103RBT6 source code Mitsubishi PL

Пн ноя 05, 2018 19:24:03

как так не выкладываем ? еще как выкладываем

то что я выложил ранее то и осталось
я пока ничего не менял (практически)
только заменил u8 и u16 на u32 везде, что дало умопомрачительный эффект по уменьшению размера кода

Добавлено after 5 minutes 2 seconds:
Re: Open source plc STM32F103RBT6 source code Mitsubishi PLCFX1
вона я даже выложил список команд с кодами ПЛК
пока я их выковырял, скока нервов, а тут народ спрашиваю, а в ответ тишина, народ готового ждет

Re: Open source plc STM32F103RBT6 source code Mitsubishi PL

Вт ноя 06, 2018 08:21:16

Мурик, все исходники выложены, что еще надо?????????

imsushka, попробую заменить но не на u32 а на uint32_t (стандарт как ни как)...

Re: Open source plc STM32F103RBT6 source code Mitsubishi PL

Вт ноя 06, 2018 10:12:06

dosikus писал(а):все исходники выложены
Где?

Re: Open source plc STM32F103RBT6 source code Mitsubishi PL

Вт ноя 06, 2018 10:36:56

Добавлено: Чт окт 04, 2018 19:40:02

полный файл с библиотеками от ст
ранее выкладываемый newnew - был без библиотек

компилица без ошибок


Вложения:
FX2N_MODBUS_RTC_AD_DA_V3.8.rar [698.06 KiB]
Скачиваний: 23


месяц, больше даже

23 раза скачали !!!!!

Re: Open source plc STM32F103RBT6 source code Mitsubishi PL

Ср ноя 07, 2018 16:59:07

а у ДМА есть режим декрементного обращения к памяти ?
если нету то как это можно организовать не програмно ?

выходы в памяти сидят от Y000 до Y377 а в железе от основного модуля (с Y000 ) до модулей расширения (Y377)
дма будет брать данные с 0 и гнать в SPI и в этом случае выходы будут начинаться с модуля расширения

если же есть декрементный режи то проблем нету

Re: Open source plc STM32F103RBT6 source code Mitsubishi PL

Ср ноя 07, 2018 20:42:15

Почему декрементный?

Re: Open source plc STM32F103RBT6 source code Mitsubishi PL

Чт ноя 08, 2018 04:48:03

инсрементный - увеличивает адрес при каждой итерации (n, n+1, n+2 ..... )
декрементный - уменьшает адрес (n-10, n-9, n-8 ..... )

в х86 есть (был) такой режим

Re: Open source plc STM32F103RBT6 source code Mitsubishi PL

Чт ноя 08, 2018 08:57:42

Это-то ясно.
Непонятно зачем тебе здесь это нужно и причем здесь спи?

Re: Open source plc STM32F103RBT6 source code Mitsubishi PL

Чт ноя 08, 2018 09:30:34

хочу порты ввода вывода на SPI повесить (мне в одной задаче надо 500-600 в/в)
595 и 165
а на мк оставить только аналоговые / 8 входов (можно на таймер завести, типа высокоскоростного счетчика) и 8 выходов (можно тоже на таймер , ШИМ или пульсации)

прогу записывать не во флеш, а на SD карту
а выполнять из RAMы, при пропадании питания загружать из СД

Re: Open source plc STM32F103RBT6 source code Mitsubishi PL

Чт ноя 08, 2018 10:34:43

Ясно, снова не понятно почему декрементный - железо же сам разрабатываешь, сам выводы назначаешь.
Работа с SD карточкой - фатфс и дма, уже обкатано на спи.

Re: Open source plc STM32F103RBT6 source code Mitsubishi PL

Чт ноя 08, 2018 11:16:37

есть кусок памяти где лежат Y000-Y377 , одращение из проги просто и логично

есть модули расширения

если выпихивать просто из этих адресов в SPI - то выпихивацца будет так Y000 Y010 ..... Y377 - это не нормально, должно быть так Y377 Y376 .. Y001 Y000
а впихивацца X000 X001 ... X377 - это нормально

я могу перед отправкой програмно развернуть в другой буфер , но тогда смысла нету использовать ДМА, проще по прерыванию от SPI брать откуда хошь данные и выводить

а хотелось бы 1 раз настроить и забыть об портах ввода вывода
Вложения
Безымянный.png
(11.76 KiB) Скачиваний: 643

Re: Open source plc STM32F103RBT6 source code Mitsubishi PL

Чт ноя 08, 2018 11:55:51

то выпихивацца будет так Y000 Y010


С чего вдруг?

Re: Open source plc STM32F103RBT6 source code Mitsubishi PL

Чт ноя 08, 2018 12:20:46

как с чего ?!?
по адресу PLC_8BIT(0x0080) лежит байт с данными Y007 Y006 ... Y001 Y000
по адресу PLC_8BIT(0x0081) лежит байт с данными Y017 Y016 ... Y011 Y010
соотвественно и выпихнецца Y000 Y010 ...
а я хочу наиборот
PLC_8BIT(0x008F)
PLC_8BIT(0x008E)
PLC_8BIT(0x008D)
..
PLC_8BIT(0x0081)
PLC_8BIT(0x0080)

Re: Open source plc STM32F103RBT6 source code Mitsubishi PL

Вт ноя 13, 2018 14:54:55

надо тотальную проверку работоспособности конанд сделать
а то такое ощущение что часть копировалась из других и не модифицтровалась

Re: Open source plc STM32F103RBT6 source code Mitsubishi PL

Пн ноя 26, 2018 23:37:23

а у ДМА есть режим декрементного обращения к памяти ?
если нету то как это можно организовать не програмно ?
Только инкремент.
Не программно не получится. 100500 придётся юзать SPI прерывание TXE.
Ответить