コメント無し

# 外観  ## ＡＤＳＲ入力例の動画 Facebookに紹介動画があります。（Facebookへのログインが必要です） https://www.facebook.com/toshikazu.hyodo/videos/1216092900384973?idorvanity=247733226639836 # 用途（課題） - この作品は、FM音源IC（YMF825）のパラメータをグラフィックに編集するための作品です。 FM音源のパラメータは、数値だけではイメージがつかみにくいものです。 - ADSRパラメータの編集は、ADSRの折れ線グラフのようなものを表示して、グラフの偏移点をつまんで操作できれば全体のイメージがつかみやすくなります。 - 音源のパラメータの選択肢もパラメータの番号ではなく、HzやdBなどで表されるパラメータを表示して選択できれば分かりやすくなります。 - ここでは、FM音源のパラメータ編集方法ですが、相互に関連するパラメータを設定する場面では参考になると思います。 # 編集画面の構成方法について - FM音源IC YMF825 には、16種類の楽器に相当する音源の設定ができます。 - 各音源にはBO、LFO、ALGという３つのパラメータと、17種類のパラメータをもつ４オペレータがあります。 - ４オペレータには、それぞれ SR、LOF、KSR、RR、DR、AR、SL、TL、KSL、DAM、EAM、DVB、EVB、MUL、DT、WS、FBという17種類のパラメータがあります。 - すなわち、１つの音源には、3 + 17 * 4 ＝ 71のパラメータがあります。 パソコンであれば、大きな画面で、すべてのパラメータを表示して操作することが可能だと思いますが、今回利用したタッチパネル付きＬＣＤは、画面が小さいので、４つのオペレータ別にパラメータを編集しています。 - シンセサイザーの中核の部分は、いわゆるADSR（AR DR SR RR）のパラメータですが、一つの画面で折れ線グラフを操作するようなイメージで編集します。YMF825には、SLというパラメータもありますので加えています。また、KSL、KSRというパラメータも含めました。 - WS（Wave Shapes）：音源の波形の選択では、29の波形のイメージ表示してそれをタッチ選択するようにしました。 ALG（Algorithm）：アルゴリズムは、４つのオペレータをどのような組み合わせるかの選択ですが、これも７つのアルゴリズムのイメージを表示して、タッチ選択できるようにしました。 - なお、素人の理解で作ったFM音源パラメータ編集プログラムです。間違いや勘違いがあると思います。ご利用される場合は自己責任でお願いします。 # 概要（作品全体の説明） - ２つのPicoが連携して動作します。PicoMainとPicoSubと呼びます。 - PicoMainは音源編集用、PicoSubはYMF825を接続してMIDI再生（発音）用です。 - PicoMainには、パラメータをグラフィックに編集するためにタッチパネル付き液晶（Waveshare 3.5型静電容量式タッチスクリーンディスプレイ 320 x 480 SPI接続）を接続しました。Waveshare社の商品名は、Pico-ResTouch-LCD-3.5です。 - PicoMainとPicoSubは、シリアル通信し、PicoMainで編集した音源のパラメータや発音のモードなどをPicoSubに送信します。 - PicoSubは、PicoMainから受信がないときは、MIDI端子から受信してYMF825で演奏するとともに、MIDI-OUT端子にも出力します。 - 紹介動画では、MIDI-OUT端子にポケット・ミクを接続しています。ポケット・ミクは、USB端子ですので変換アダプタを挟んでいます。 ポケット・ミクは、チャンネル０にミクの音声が固定されています、チャンネル０を出力しないでポケット・ミクが持つＧＭ音源を伴奏に利用できるように工夫しました。 # 主要部品 |デバイス名|用途|接続方法| |:-------------------------|:--------------|:-------------|:----------------| |Pimoroni Pico Plus2| PicoMain：音源編集用|PicoSubとシリアル接続| |Waveshare 3.5型静電容量式タッチパネルＬＣＤ|編集画面表示・タッチ入力用| PicoMain にSPI接続| |Raspberry Pi Pico | PicoSub：YMF825制御用| PicoMainとシリアル接続| |YMF825（YAMAHA FM音源）|設定された音源でMIDI再生| PicoSub とSPI接続| |MIDIインターフェース|MIDI再生の入力と出力|PicoSubにシリアル接続| ## 入手先など（ご参考） Waveshare 3.5型静電容量式タッチパネルＬＣＤ Waveshare Pico-ResTouch-LCD-3.5 > https://www.waveshare.com/wiki/Pico-ResTouch-LCD-3.5 Pimoroni Pico Plus 2 > https://www.switch-science.com/products/9906 Raspberry Pi Pico > https://akizukidenshi.com/catalog/g/g116132/ YMF825（YAMAHA FM音源）・・・残念ながら販売終了です。 > https://akizukidenshi.com/catalog/g/g112414/ MIDIインターフェイス基板キット > https://akizukidenshi.com/catalog/g/g111112/ # 実体配線図  - PicoMain側は、Pico-ResTouch-LCD-3.5の背面にある40PinのPico用のソケットにPimoroni Pico Plus2を装着するだけです。ソケットに差し込めるよう、予めPimoroni Pico Plus2にヘッダーピンを半田付けする必要があるのと、PicoSub側とのシリアル通信の配線はありますが、追加したハードウェアはありません。 - PicoMainとPicoSubは、5Vの電源ラインも接続して、どちらかのUSB端子に電源供給されれば、PicoMainとPicoSub両方が動作します。 - Pico-ResTouch-LCD-3.5には、SDカードインターフェースも付属しています。編集した音源のパラメータをSD-Cardに保存・読み出しに利用しました。提供されているサンプルプログラムを参考にすると簡単に繋げました。 ## PicoMain とＬＣＤ、タッチパネル、ＳＤカードとのSPIデバイス接続 - Pico-ResTouch-LCD-3.5の背面にある40PinのソケットにPicoMain（Pimoroni Pico Plus2）を装着すると、次の通りSPI接続されます。 - このSPI接続では、同じMOSI、MISO、SCKを使って、CS端子の仕様を、LCDの場合はLCD_CS、タッチパネルの場合はTP_CS、SD-Cardの場合はSD_CSに切り替えて使用する仕組みなっています。 ### Pico（Pimoroni Pico Plus2）と Pico-ResTouch-LCD-3.5 との gpio接続 |信号名|Pico gpio番号| |:-------------------------|:--------------| |LCD_DC |Pin(8, Pin.OUT)| |LCD_CS |Pin(9, Pin.OUT)| |LCD_SCK |Pin(10)| |LCD_MOSI |Pin(11)| |LCD_MISO |Pin(12)| |LCD_BL |Pin(13, Pin.OUT)| |LCD_RST |Pin(15, Pin.OUT)| |TP_CS |Pin(16, Pin.OUT)| |TP_IRQ |Pin(17, Pin.IN)| |SD_CS |Pin(22, Pin.OUT)| ## PicoSub側 のYMF825 および MIDI端子との接続 PicoSub（Raspberry Pi Pico）側では、FM音源IC（YMF825）をSPI接続して、MIDI端子をシリアル接続しています。  ### FM音源IC（YMF825）とのSPI接続 |PicoSub gpio name| (pin) |配線色|(pin)| YMF825| |:--------------|:----:|:----:|:---:|:---:| | gpio-17 SPI CS | (22) | 白 | (1) | SS | | gpio-19 SPI MOSI | (25) | 青 | (2) | MOSI | | gpio-16 SPI MISO | (21) | 緑 | (3) | MISO | | gpio-18 SPI CLK | (24) | 黄 | (4) | CLK | | GND | | 白 | (5) | GND | | 5V | | 橙 | (6) | VCC | | gpio-22 RESET | (29) | 紫 | (7) | RST | | No Connect | | | (8) | NC | ### YMF825 Monitor LED-BLUE（Note Onの期間中点灯） |PicoSub gpio name| (pin) |接続部品| GND | |:--------------|:----:|:----:|:---:|:---:| |gpio-28 | (34) |BLUE-LED Anode | BLUE-LED Cathode| ### PicoSub RUN スイッチ（PicoSubのリセット） |PicoSub gpio name| (pin) |接続部品| GND | |:--------------|:----:|:----:|:---:| |RUN | (30) | RUN Switch | RUN Switch | ### PicoSub とMIDI端子の接続 |PicoSub gpio name| (pin) |配線色|接続先| |:--------------|:----:|:----:|:---:|:---:| |gpio-1 UART0 TxD| (1) | 黄 |TX信号ドライブ回路の入力へ| |gpio-2 UART0 RxD| (2) | 緑 |カレント・ミラー回路の出力から| MIDI の受信（RXD）と送信（TXD）の信号波形改善のため、受信回路には２つのトランジスタでカレントミラー回路構成し、送信回路にはドライバーとして74HC04（インバータ）を入れました。   # PicoMainとPicoSub との シリアル接続 | PicoMain| (pin) |配線色|配線色| (pin)| PicoSub| |:---------------|:-----:|:----:|:-----:|:----:|:----------------:| |gpio-2 respT |(4)| 紫 | 黄 |(4)| respT gpio-2| | | |ここでクロス| | | | |gpio-3 respR |(5)| 黄 | 紫 |(5)| respR gpio-3| ||||||| |gpio-4 TX |(6)| 緑 | 青 |(6)| TX gpio-4| | | |ここでクロス| | | | |gpio-5 RX |(7)| 青 | 緑 |(7)| RX gpio-5|   ### PicoMainからPicoSubへの送信手順 PicoSubは通常、MIDI信号を受信して再生（音出し）処理をしています。突然、PicoMainからデータが送られてきても対応できませんので、次のような手順で通信するようにプログラムしてします。 - PicoMainは、PicoSubへの送信データがあるなら、respTをLowにしてPicoSubに受信を要求します。 - PicoSubは、処理の合間にrespRをポーリングして、Lowを検知したら、受信モードに移行してrespTをLowにして、受信体制が整ったことをPicoMainに知らせます。 - PicoMainは、PicoSubからrespRが返ってきたら、TXを使って115200Kbpsでデータ送信し、PicoSubは受信します。 - 送信が終わったらPicoMainは、respTをHighにし、PicoSubも、respTをHighにして通信は終了します。 # PicoMainに「Pimoroni Pico Plus2」を採用した理由（読み飛ばし可） - Pico-ResTouch-LCD-3.5は、背面にある40PinのソケットにRaspberry Pi Pico2を装着するだけでMicroPythonのFramebufferを利用して、文字を描く、線を引く、点を打つ、四角を描くなどのプログラムが簡単に作れます。 - しかし、LCD 320 x 480 １画面分で307200バイトのメモリを必要としますので、Pico2（PicoではなくPico2）のメモリ（520KBのSRAM）でも、残りのメモリでは小さなプログラムしか動かせません。 Waveshare社のサイトで提供されているサンプルプログラムでは、画面の半分のバッファを用意して、プログラム領域を確保していますが、画面・半分だけのバッファではプログラムが煩雑になります。 - 今回、PicoMainにPimoroni Pico Plus2を採用したのは、メモリを気にすることなくプログラムするためです。Pimoroni Pico Plus2は、8MBのPSRAMを搭載していますので、Pico2よりも約16倍のメモリが使えます。 - ところがPimoroni Pico Plus2を利用すると嵌まり込む症状が出て解決するのに時間がかかりました。SPIの速度を、Pico2で動作していた40MHzから20MHzに変更したら症状は出なくなりました。SPIの動作を見ると、実際にはその60％ 12MHzで動作しています。表示速度は落ちますが、大きなプログラムを作れるので良しとしました。 # プログラム開発環境（読み飛ばし可） - Raspberry Pi 4B にRaspberry Pi OSを標準でインストールするとThonnyが入ります。そのThonnyだけを使って開発しました。 - すべてのプログラム言語は、MicroPythonです。 - Pimoroni Pico Plus2 または Raspberry Pi Pico2をUSBケーブルでRaspberry Pi 4BにUSB接続して、Thonnyを起動させれば準備完了ですが、初めて接続する場合には、Pimoroni Pico Plus2 または Raspberry Pi Picoに、MicroPythonファームウェア（UF2 ファイル）を書き込む必要があります。ご存じない方は、ネットで検索してください。ファームウェアはMicroPython用を導入してください。 - Raspberry Pi Pico の場合はThonnyからインストールできますが、Pimoroni Pico Plus2は、専用のサイトからUF2ファイルをダウンロードする必要があります。 - Thonnyのシェル画面に表示されるシリアル出力のみでデバッグしました。 # プログラムの紹介 ## PicoMain側のプログラム PicoMainプログラムは、次のプログラムで構成されています。 ### main.py ```MicroPython:main.py ######################################################################## # 2025/11/06 Programed by Hyodot # PicoM_YMF825Edit-152.py # PicoSub 側 # PicoS_YMF825Midi-023.py # YMF825用のパラメータ設定用 PicoMain用のプログラムである。 # LCDタッチパネル WAVE SHARE Pico-ResTouch-LCD-3.5 を利用して # グラフィックな編集を実現する。ADSRなどの操作はわかりやすくなる。 ######################################################################## # # 2025/08/02 : ADSRの表示と入力、WSの表示、ALGの表示まで完成させた # main_YMF825_PicoM-047_AdsrTest.py # をベースに開発している。実行には、上記から関数群を分離した # tone_edit.py # を必要とする。 # # tone_edit.pyは、LCD表示とタッチセンス部分をライブラリとして独立させた # touch_lcd.py # を必要とする。 # touch_lcd.pyは、 # WAVE SHARE Pico-ResTouch-LCD-3.5 で用意された main_3inch5.py を改良した # touch_lcd-20250814-No3TouchLCD.py # をベースにしている。 # # 2025/08/14：Pico2は、RAMが520KB FrameBufferを使った大きなプログラムが # 作れないので、Pimoroni Pico Plus 2 PSRAM 8MB を利用する。 # PimoroniPicoPlus2で、WAVE SHARE Pico-ResTouch-LCD-3.5 を動作させると # はまり込む症状が出たが、SPIの周波数を40MHzから20MHzに変更すれば解決した。 # 20MHzを指定しても、実際の動作は６割の12MHzでしか動作していないが良しとする。 # # 設定した音源データ（ToneData）を SD-CARDに書き込み・読み込みができるようにした。 # SD-CARD への Read Write は、sdcard.py を利用する。 # sdcard.py では、touch_lcd.py で使用している SPI-1 を共有しているが、 # 特に意識して切り替えをしなくても問題なく動作している。よくわからないが良しとする。 # # YMF825 を搭載した PicoSub とシリアル通信で設定した Tone Data を送信する # # # # ######################################################################## from machine import Pin, SPI, PWM from micropython import const import time import utime import os import vfs # 仮想ファイルシステム import gc # メモリ利用状況表示用 import ymf825py as ymf825 import mojipy as moji # edit_tone.py から必要な関数をインポートする # import した「関数名」で利用できる。 print(f'Function Program Loading Start ... ') from tone_edit import spi_change2_lcd from tone_edit import dspFill from tone_edit import dspShow from tone_edit import dspColorlist from tone_edit import dspFillUpper from tone_edit import dspFillLower from tone_edit import dsp_menu from tone_edit import edit_menu from tone_edit import select_MainMenu from tone_edit import select_SubMenu from tone_edit import select_SubCom_tab from tone_edit import select_SubOp_tab from tone_edit import select_ALG from tone_edit import dsp_text_bar from tone_edit import dsp_ALGup from tone_edit import dsp_ALG_TN from tone_edit import wave_form from tone_edit import select_WS from tone_edit import edit_mul from tone_edit import edit_adsr from tone_edit import edit_dam from tone_edit import edit_bo from tone_edit import select_ToneNumber from tone_edit import select_SwapCh from tone_edit import edit_ToneName from tone_edit import select_Item from tone_edit import select_CanExe from tone_edit import edit_text # SD-Card from sdcard import SDCard print(f'Library Program Loading End') ######################################################################## print(f'main MicroPython Start ... gc.mem_alloc() = {gc.mem_alloc()}') ######################################################################## # UART PicoSub uartRespT = Pin(2, Pin.OUT) # Low True uartRespT.value(1) uartRespR = Pin(3, Pin.IN) # Low True # SD-Card sdcardCS = Pin(22, Pin.OUT) # main-tab sub-tab のタブ番号 tabGET = const(1) tabCOM = const(2) tabOP = const(3) tabPUT = const(4) tabALG = const(1) tabBO = const(2) tabLOF = const(3) tabWS = const(1) tabMUL = const(2) tabADSR = const(3) tabDAM = const(4) tabMR = const(1) tabYMF = const(1) tabSD = const(2) tabMODE = const(4) OP_max = const(0) OP1 = const(1) OP2 = const(2) OP3 = const(3) OP4 = const(4) # YMF825 より引用 # カラー設定を取り込み、カラー定数設定 lcd_color_list = dspColorlist() BLACK = lcd_color_list[0] RED = lcd_color_list[1] GREEN = lcd_color_list[2] BLUE = lcd_color_list[3] YELLOW = lcd_color_list[4] PURPLE = lcd_color_list[5] BLUEGREEN = lcd_color_list[6] GRAY = lcd_color_list[7] WHITE = lcd_color_list[8] # VOICE COMMON PARAMETER ROW s Number COM = const(0) BO = const(1) LFO = const(2) ALG = const(3) VOICE_COM_COL_NUM = const(4) # VOICE COMMON PARAMETER COLUMON s Number CM0 = const(0) # Oparator Name CM1 = const(1) # Edit CM2 = const(2) # Orig CM3 = const(3) # Max VOICE_COM_ROW_NUM = const(4) # 20240326 Change # VOICE OPTIONAL PARAMETER ROW s Number OPT = const(0) SR = const(1) XOF = const(2) KSR = const(3) RR = const(4) DR = const(5) AR = const(6) SL = const(7) TL = const(8) KSL = const(9) DAM = const(10) EAM = const(11) DVB = const(12) EVB = const(13) MUL = const(14) DT = const(15) WS = const(16) FB = const(17) VOICE_OP_ROW_NUM = const(18) # ymf825の音源（音色）について # Common は、音源（音色）毎に１つである com_BO = ymf825.Voice_Com_Edit[BO][CM1] com_LFO = ymf825.Voice_Com_Edit[LFO][CM1] com_ALG = ymf825.Voice_Com_Edit[ALG][CM1] # Operator # オペレーション・パラメータは、音源（音色）毎に４つのオペレータがある OP_num = 1 ''' YMF825 Tone Data には、 Tone_Com_Orig + Tone_Op_Orig # YAMAHA Original Tone_Com_Edit + Tone_Op_Edit # 編集用 があり、Tone_Com_Edit + Tone_Op_Edit を要素毎に分解した Voice_Com_Edit + Voice_Op_Edit # 要素編集用 がある。 # Common BO, LFO, ALG の最大値 Voice_Com_Max = [3, 3, 7] # Common SR, XOF, KSR, RR, DR, AR, SL, TL, KSL, DAM, EAM, DVB, EVB, MUL, DT,WS, FB の最大値 Voice_Op_Max = [15, 1, 1, 15, 15, 15, 15, 63, 3, 3, 1, 3, 1, 15, 7, 31, 7] 以下は、ymf825.serialOutVoiceData(putTN) により Voice_Com_Edit + Voice_Op_Edit をシリアル出力（プリント）したものである。 Voice Number = 0 : GRAND_PIANO Common : Edt| Org| Max| BO : 0| 0| 3| LFO : 1| 1| 3| ALG : 3| 3| 7| Operator : e1| e2| e3| e4| o1| o2| o3| o4| Mx| SR : 0| 2| 1| 2| 0| 2| 1| 2| 15| XOF : 0| 0| 0| 0| 0| 0| 0| 0| 1| KSR : 0| 1| 0| 1| 0| 1| 0| 1| 1| RR : 6| 3| 4| 6| 6| 3| 4| 6| 15| DR : 7| 3| 1| 2| 7| 3| 1| 2| 15| AR : 15| 14| 13| 13| 15| 14| 13| 13| 15| SL : 15| 2| 3| 4| 15| 2| 3| 4| 15| TL : 39| 40| 34| 0| 39| 40| 34| 0| 63| KSL : 1| 3| 0| 2| 1| 3| 0| 2| 3| DAM : 0| 0| 0| 0| 0| 0| 0| 0| 3| EAM : 0| 0| 0| 0| 0| 0| 0| 0| 1| DVB : 0| 0| 0| 0| 0| 0| 0| 0| 3| EVB : 0| 0| 1| 1| 0| 0| 1| 1| 1| MUL : 1| 5| 1| 1| 1| 5| 1| 1| 15| DT : 0| 0| 0| 0| 0| 0| 0| 0| 7| WS : 8| 0| 0| 0| 8| 0| 0| 0| 31| FB : 0| 0| 0| 0| 0| 0| 0| 0| 7| ''' # PicoSub' YMF825 MIDI Play Mode # PicoSub 側では、'Ch0_Waon+4sec' 'Ch0_Waon+Normal' いずれのモードでも # MIDI のプログラムチェンジを受け付けると Ch0 和音対応を解除して、MIDI信号に対応した発音にする。 mode_list = [ 'Init_YMF825', # YMF825 を初期設定する 'All_Note_Off', # すべてのチャンネルのノートオフ 'Ch0_Waon+4sec', # Ch0 和音対応 ４秒維持 'Ch0_Waon+Normal', # Ch0 和音対応 ４秒維持はしない 'With_Out_Ch0', # Ch0 を MIDI出力しない 'Swapping_Ch0>', # Ch0 を 指定した MIDI Ch に出力する ] ############################################################### # HandShake Send RTS & Recive CTS Cross Connection # PicoMain から PicoSub に respT(RTS) を 0 とすることで通信を要求し、 # PicoSub から PicoMain に respR(CTS) を 0 とすることで通信を開始する # PicoMain と PicoSub との接続 # <<< PicoMain >>> <<< PicoSub >>> # gpio-2 respT (4) --紫-- --黄-- (4) respT gpio-2 # X # gpio-3 respR (5) --黄-- --紫-- (5) respR gpio-3 # # gpio-4 TX (6) --緑-- --青-- (6) TX gpio-4 # X # gpio-5 RX (7) --青-- --緑-- (7) RX gpio-5 ############################################################### def waitCTS(rts, time, msg, cnt): global uart_timer if rts == 0: # Send RTS On uartRespT.value(0) uart_timer = time # Wait CTS On while uartRespR.value() == 1: # On == Low になるのを待つ if uart_timer == 0: print(msg) uart_timer = time if cnt > 0: cnt -= 1 else: break # Pico Sub と UART 通信できない utime.sleep_ms(10) else: # Send RTS Off uartRespT.value(1) uart_timer = time # Wait CTS Off while uartRespR.value() == 0: # Off == High になるのを待つ if uart_timer == 0: print(msg) uart_timer = time if cnt > 0: cnt -= 1 else: break # Pico Sub と UART 通信できない utime.sleep_ms(10) return cnt ####################################################################### def setToneDataPicoSub(edit_num, save_num): print('setToneDataPicoSub(edit_num)') # Sub Pico へ送信要求を送出 print('RTS On to Sub_Pico') cnt = 3 cnt = waitCTS(0, 1000, 'Wait Sub_Pico CTS On', cnt) if cnt > 0: # print('CTS On(0) from Sub_Pico') # ToneVoice をシリアル出力 ymf825.serialOutVoiceData(edit_num) # Tone_Com_Edit, Tone_Op_Edit を ASCII２文字の send_buffに変換 # ymf825.serialOutToneData(edit_num) # 20240727 Change 保存するときに ToneNumber を指定できるようにした ymf825.takeOutToneData2(edit_num, save_num) # send_buff を UART で送信 ymf825.uartOutToneData() utime.sleep_ms(10) # Sub Pico へ送信要求の解除を送出 print('RTS Off to Sub_Pico') cnt = 3 cnt = waitCTS(1, 1000, 'Wait Sub_Pico CTS Off', cnt) if cnt > 0: print('CTS Off(1) from Sub_Pico') print('ymf825.uartOutToneData() was performed') else: print() print('CTS Off(1) signal not comming from Sub-Pico') print('Check the connection with Sub-Pico') print() else: print() print('CTS On(0) signal not comming from Sub-Pico') print('ymf825.uartOutToneData() was not performed !!!') print('Check the connection with Sub-Pico') print() # Send RTS Off uartRespT.value(1) ####################################################################### # PicoSub MIDI Play Mode Set # [All_Note_Off] [Normal] [Ch0_Waon] [Ch0_Waon+Delay4] def setPlayModePicoSub(command): print('setPlayModePicoSub(command)') # Sub Pico へ送信要求を送出 print('RTS On to Sub_Pico') cnt = 3 cnt = waitCTS(0, 1000, 'Wait Sub_Pico CTS On', cnt) if cnt > 0: # print('CTS On(0) from Sub_Pico') ####################################################### ymf825.uart_write_multi(command) ####################################################### utime.sleep_ms(10) # Sub Pico へ送信要求の解除を送出 print('RTS Off to Sub_Pico') cnt = 3 cnt = waitCTS(1, 1000, 'Wait Sub_Pico CTS Off', cnt) if cnt > 0: print('CTS Off(1) from Sub_Pico') print('setPlayModePicoSub(command) was performed') else: print() print('CTS Off(1) signal not comming from Sub-Pico') print('Check the connection with Sub-Pico') print() else: print() print('CTS On(0) signal not comming from Sub-Pico') print('!!! setPlayModePicoSub(command) was not performed !!!') print('Check the connection with Sub-Pico') print() # Send RTS Off uartRespT.value(1) ####################################################################### def setToneTablePicoSub(): print('setToneTablePicoSub()') # Sub Pico へ送信要求を送出 print('RTS On to Sub_Pico') cnt = 3 cnt = waitCTS(0, 1000, 'Wait Sub_Pico CTS On', cnt) if cnt > 0: # print('CTS On(0) from Sub_Pico') # ToneTable を ASCII２文字の send_buffに変換 ymf825.takeOutToneTable() # ToneTableリストを UART に転送 ymf825.uartOutToneTable() utime.sleep_ms(10) # Sub Pico へ送信要求の解除を送出 print('RTS Off to Sub_Pico') cnt = 3 cnt = waitCTS(1, 1000, 'Wait Sub_Pico CTS Off', cnt) if cnt > 0: print('CTS Off(1) from Sub_Pico') print('ymf825.uartOutToneTable() was performed') else: print() print('CTS Off(1) signal not comming from Sub-Pico') print('Check the connection with Sub-Pico') print() else: print() print('CTS On(0) signal not comming from Sub-Pico') print('ymf825.uartOutToneTable() was not performed !!!') print('Check the connection with Sub-Pico') print() # Send RTS Off uartRespT.value(1) # SD-CARD のファイルリスト # Waveshare sdcard_demo.py より引用 def print_directory(path, tabs = 0): for file in os.listdir(path): stats = os.stat(path+"/"+file) filesize = stats[6] isdir = stats[0] & 0x4000 if filesize < 1000: sizestr = str(filesize) + " by" elif filesize < 1000000: sizestr = "%0.1f KB" % (filesize/1000) else: sizestr = "%0.1f MB" % (filesize/1000000) prettyprintname = "" for i in range(tabs): prettyprintname += " " prettyprintname += file if isdir: prettyprintname += "/" print('{0:<40} Size: {1:>10}'.format(prettyprintname, sizestr)) # recursively print directory contents if isdir: print_directory(path+"/"+file, tabs+1) # SD-CARD 指定パス直下のファイルリスト。ソートした結果を返す。 def sd_file_list(path): file_list = list() for file in os.listdir(path): stats = os.stat(path+"/"+file) filesize = stats[6] isdir = stats[0] & 0x4000 if not isdir: file_list.append(file) print() print(f'file_list = {file_list}') # リスト形式を タプル形式に変換 tpl_list = tuple(file_list) # タプル形式で、ソートを実施して、リストに戻す # tpl_list = tuple(sorted(tpl_list)) # これは、タプルに戻す場合 file_list = sorted(tpl_list) # 拡張子 .txt を取り除く（この処理、ファイル名の本体に .txt が無いことが前提） for i in range(len(file_list)): file_list[i] = file_list[i].replace('.txt', '') return file_list # SD-card から Tone Dataを読み込み # Tone Data は、100バイト、１行のみである def readToneData_fromSD(file_path): # 指定されたファイルを読み込み、ymf825.rcv_tone に展開する # この時点では、Tone Data として取り込むか否かは決定していない。 with open(file_path, 'r') as f: ymf825.rcv_buff = f.readline() if len(ymf825.rcv_buff) == 100: # Tone Data として取り込むには、ymf825.takeInToneData() を実行すればよいが、 # tone_num tone_name を取得して確認する tone_num = moji.asc2int(ymf825.rcv_buff[ymf825.TONE_HEADER:ymf825.TONE_HEADER +2]) print(f'tone_num = {tone_num}') ymf825.rcv_tone = [] for i in range(ymf825.UART_TONE_NUM): #42 ymf825.rcv_tone.append(moji.asc2int(ymf825.rcv_buff[ymf825.TONE_HEADER +i *2 : \ ymf825.TONE_HEADER +i *2 +2])) print(f'ymf825.rcv_tone = {ymf825.rcv_tone}') # tone_name の取得と更新 ymf825 1141行あたりの処理 tone_name = ymf825.rcv_buff[1:ymf825.TONE_HEADER].strip() # 末尾のスペースを取り除く print(f'Recive Data Tone Name = {tone_name}') else: print(f'len(ymf825.rcv_buff) = {len(ymf825.rcv_buff)} does not 100 bytes') tone_num = 0 tone_name ='' return len(ymf825.rcv_buff), tone_num, tone_name ######################################################################## # MicroPython Start ######################################################################## # カラー表示テスト ・・・ 不要であるが for i in range(len(lcd_color_list)): dspFill(lcd_color_list[i]) dspShow() utime.sleep_ms(100) # ToneNo 0-15 getTN = 0 putTN = 0 # 何も指定しなくても編集を開始できるように 0:GrandPiano を読み込んでおく # YMF825 Grand Piano Tone Data Set ymf825.copyTone2_Voice(getTN) # main-menu sub-menu の初期設定 tabM_num = 0 # MainTab 毎に SubTab があるので、管理しやすくするために # tabM_num 0, 1, 2, 3, 4 tabL = [0, 0, 0, 0, 0] tabS_num = tabL[tabM_num] # 直前の処理状況を edit_menu(tabM_num, tabS_num, processMsg) により画面表示する processMsg = 'Program Start' print(processMsg) # SD-CARD モジュール起動 # LCD TouchPanel と SPI が共通なのだが、特に切り替えをしなくても動作している spi = SPI(1, baudrate=60_000_000, sck=Pin(10), mosi=Pin(11), miso=Pin(12), \ polarity=0, phase=0) # from sdcard import SDCard ############################################################################ sd = SDCard(spi, Pin(22, Pin.OUT), 30_000_000) processMsg = 'sd = SDCard(spi, Pin(22, Pin.OUT), 30_000_000)' print(processMsg) # PicoM_YMF825Edit-136.py 以前では、 # Thonny による停止ボタン、起動ボタンでは２回目の起動で必ずエラーになる（タイムアウト） # 次のようにすることで回避できた。 # SD-Card 接続：vfs.mount(sd, '/sd') でエラーならば、vfs.umountを入れる。 # SD-Card 切断：vfs.umount('/sd') ではなく vfs.umount('/') を実行してから # SD-Card 接続：vfs.mount(sd, '/sd') すればよい。より確実と思われる方法にしてみた。 # vfs.mount() により、現在の接続情報が得られるが、リスト内にタプル形式で収納されている。 # print(f'vfs.mount() = {vfs.mount()}') print('command: mount_value = vfs.mount()') mount_value = vfs.mount() # mount_value は、リスト print('command: vfs_obl, mount_point = mount_value') vfs_obj, mount_point = mount_value[0] print(f'result: mount_point = {mount_point}') try: print("command: vfs.mount(sd, '/sd')") vfs.mount(sd, '/sd') except: print(f"Error On : vfs.mount(sd, '/sd')") print(f"command: vfs.umount({mount_point})") # vfs.umount('/sd') は NG vfs.umount('/') なら OK vfs.umount(mount_point) print("command: vfs.mount(sd, '/sd')") vfs.mount(sd, '/sd') print(f'vfs.mount() = {vfs.mount()}') # ############################################################################ ######################################## # main loop ######################################## while True: dsp_menu(tabM_num, tabL[tabM_num]) if tabM_num == tabGET: print(f'tab[GET] was selected') if tabL[tabM_num] == tabMR: print(f'tab[MR]:memory was selected') # getTN（Tone Number）選択 guide_msg1 = 'Get Tone Data' guide_msg2 = 'Select Tone Number' getTN_old = getTN # (btn, getTN) = select_ToneNumber(guide_msg, getTN_old) tabM_num_old = tabM_num (tabM_num, tabL[tabM_num_old], btn, getTN) = \ select_ToneNumber(tabM_num, tabL[tabM_num], guide_msg1, guide_msg2, \ getTN_old, ymf825.ToneName) if getTN_old != getTN: print(f'Tone Number has changed') if btn == 'Execute': print(f'Execution Get Tone Data') ########################################################## # getTN で指定された YAMAHA の Tone Data を編集用にロードする ymf825.copyTone2_Voice(getTN) ########################################################## processMsg = 'Succeed Memory RD' print(processMsg) # main Menu 選択に移行 tabM_num = 0 elif btn == 'Cancel': processMsg = 'Cansel Memory RD' print(processMsg) getTN = getTN_old # subMenu をリセット tabL[tabM_num] = 0 # main Menu 選択に移行 tabM_num = 0 # tabM_num or tabL[tabM_num] was Changed else: print('Tab was Changed') getTN = getTN_old dspFillUpper(WHITE) elif tabL[tabM_num] == tabSD: print(f'tab[SD]:card was selected') # SD-CARD を読み込み ファイル一覧を表示、１つを選択してデータを読み込む # file_list を作成する file_list = sd_file_list("/sd") print() print(f'file_list = {file_list}') guide1 = 'Get Tone Data' guide2 = 'Select File Name' list_name = 'file name' # list を表示、 ひとつを選択する # btn, file_name = select_File(file_list, guide1, guide2, list_name) tabM_num_old = tabM_num (tabM_num, tabL[tabM_num_old], btn, file_name) = \ select_Item(tabM_num, tabL[tabM_num], file_list, guide1, guide2, list_name) print() print(f'file_name = {file_name}') if btn == 'Execute': # 指定された file_name の file_path 生成 file_name = file_name.strip()+'.txt' file_path = '/sd/'+file_name print(f'file_path = {file_path}') if file_name not in os.listdir('/sd'): # 指定されたファイルがなければ？ print('#################################################################') print(f'The file name ({file_name}) does not exist on the SD card.') print('#################################################################') # ありえないはず・・・何もしない else: # 指定のファイルがあれば SD-card の指定ファイルからデータ読み込む rcv_buff_size, tone_num, tone_name = readToneData_fromSD(file_path) if rcv_buff_size == 100: print('Tone Data') print(f'tone_num = {tone_num}') print(f'tone_name = {tone_name}') print(f'tone_data = {ymf825.rcv_tone}') # tone_number を指定して取り込む # getTN（Tone Number）選択 guide_msg1 = 'Get Tone Data' guide_msg2 = 'Select Tone Number' tone_num_old = tone_num # getTN_old = getTN # (btn, tone_num) = select_ToneNumber(guide_msg, tone_num_old) tabM_num_old = tabM_num (tabM_num, tabL[tabM_num_old], btn, tone_num) = \ select_ToneNumber(tabM_num, tabL[tabM_num], guide_msg1, guide_msg2, \ tone_num_old, ymf825.ToneName) if tone_num_old != tone_num: print(f'Tone Number has changed') # Tone Number 変更 # ymf825.takeInToneData() では、ymf825.rcv_tone[0] から取り込まれる ymf825.rcv_tone[0] = tone_num print(f'ymf825.rcv_tone[0] = {ymf825.rcv_tone[0]}') if btn == 'Execute': print(f'Execution Get Tone Data') # 読み込もうとする場所の ToneVoice をシリアル出力（プリント） ymf825.serialOutVoiceData(getTN) ################### getTN = tone_num ################### # Tone Name 更新 ymf825.ToneName[getTN] = tone_name.strip() # 末尾のスペースを取り除く # rcv_tone から Tone Data へデータ変換 ymf825.takeInToneData() ########################################################## # getTN で指定された YAMAHA の Tone Data を編集用にロードする ymf825.copyTone2_Voice(getTN) ########################################################## # ToneVoice をシリアル出力（プリント） ymf825.serialOutVoiceData(getTN) processMsg = 'Succeed SDcard RD' print(processMsg) # DEBUG 書き込み具合を見たいとき # SDカードが見られる状態にするにはここで break # break # main Menu 選択に移行 tabM_num = 0 elif btn == 'Cancel': # select_ToneNumber で btn == 'Cancel' processMsg = 'Cansel SDcard RD' print(processMsg) # subMenu をリセット tabL[tabM_num] = 0 # main Menu 選択に移行 tabM_num = 0 # tabM_num or tabL[tabM_num] was Changed else: print('Tab was Changed') else: print('rcv_buff_size is not 100') processMsg = 'Not Tone Data' print(processMsg) elif btn == 'Cancel': processMsg = 'Cansel SDcard RD' print(processMsg) # subMenu をリセット tabL[tabM_num] = 0 # main Menu 選択に移行 tabM_num = 0 # tabM_num or tabL[tabM_num] was Changed else: print('Tab was Changed') dspFillUpper(WHITE) else: dspFillUpper(WHITE) tabS_num = 0 tabM_num_old = tabM_num (tabM_num, tabL[tabM_num_old]) = select_SubMenu(tabM_num, tabS_num) processMsg = '' ######################################################################## print(f'main Loop tab[GET] end ... gc.mem_alloc() = {gc.mem_alloc()}') ######################################################################## elif tabM_num == tabCOM: print(f'tab[COM] was selected') if tabL[tabM_num] == tabALG: print(f'tab[ALG] was selected') # ALG 選択 tabM_num_old = tabM_num print(f'ymf825.Voice_Com_Edit[ALG][CM1] = {ymf825.Voice_Com_Edit[ALG][CM1]}') (tabM_num, tabL[tabM_num_old], ymf825.Voice_Com_Edit[ALG][CM1]) = \ select_ALG(tabM_num, tabL[tabM_num], ymf825.Voice_Com_Edit[ALG][CM1], \ getTN, ymf825.ToneName[getTN]) processMsg = '[ALG] Edit end' print(processMsg) elif tabL[tabM_num] == tabBO or tabL[tabM_num] == tabLOF: print(f'tab[BO] or tab[LFO] was selected') # edit BO LFO tabM_num_old = tabM_num (tabM_num, tabL[tabM_num_old], OP_num, ymf825.Voice_Com_Edit[BO][CM1],\ ymf825.Voice_Com_Edit[LFO][CM1]) = \ edit_bo(tabM_num, tabL[tabM_num], OP_num, ymf825.Voice_Com_Edit[BO][CM1], \ ymf825.Voice_Com_Edit[LFO][CM1], getTN, ymf825.ToneName[getTN]) processMsg = '[BO][LFO] Edit end' print(processMsg) else: dspFillUpper(WHITE) tabM_num_old = tabM_num (tabM_num, tabL[tabM_num_old]) = select_SubMenu(tabM_num, tabL[tabM_num]) processMsg = '' ######################################################################## print(f'main Loop tab[COM] end ... gc.mem_alloc() = {gc.mem_alloc()}') ######################################################################## elif tabM_num == tabOP: print(f'tab[OP] was selected') if tabL[tabM_num] == tabWS: print(f'tab[WS] was selected') # tabOP が選択されたら、選択されている getTN tone_name ALG を上段に表示する dsp_ALG_TN(ymf825.Voice_Com_Edit[ALG][CM1], OP_num, getTN, ymf825.ToneName[getTN]) # Select WS # OP_num は、変更されて返ってくることを前提にする OP_num_old = OP_num tabM_num_old = tabM_num (tabM_num, tabL[tabM_num_old], OP_num, ymf825.Voice_Op_Edit[WS][OP_num_old]) = \ select_WS(tabM_num, tabL[tabM_num], OP_num, ymf825.Voice_Op_Edit[WS][OP_num]) processMsg = '[WS] Edit end' print(processMsg) elif tabL[tabM_num] == tabMUL: print(f'tab[MUL] was selected') # tabOP が選択されたら、選択されている getTN tone_name ALG を上段に表示する dsp_ALG_TN(ymf825.Voice_Com_Edit[ALG][CM1], OP_num, getTN, ymf825.ToneName[getTN]) # edit MUL DT FB XOF # OP_num は、変更されて返ってくることを前提にする OP_num_old = OP_num tabM_num_old = tabM_num (tabM_num, tabL[tabM_num_old], OP_num, ymf825.Voice_Op_Edit[MUL][OP_num_old], \ ymf825.Voice_Op_Edit[DT][OP_num_old], ymf825.Voice_Op_Edit[FB][OP_num_old], \ ymf825.Voice_Op_Edit[XOF][OP_num_old]) = \ edit_mul(tabM_num, tabL[tabM_num], OP_num, ymf825.Voice_Op_Edit[MUL][OP_num], \ ymf825.Voice_Op_Edit[DT][OP_num], ymf825.Voice_Op_Edit[FB][OP_num], \ ymf825.Voice_Op_Edit[XOF][OP_num]) processMsg = '[MUL] Edit end' print(processMsg) elif tabL[tabM_num] == tabADSR: print(f'tab[ADSR] was selected') # tabOP が選択されたら、選択されている getTN tone_name ALG を上段に表示する dsp_ALG_TN(ymf825.Voice_Com_Edit[ALG][CM1], OP_num, getTN, ymf825.ToneName[getTN]) # WS 波形を表示する 上段・右下 z = [250, 180] color_back = GREEN color_wave = PURPLE wave_form(ymf825.Voice_Op_Edit[WS][OP_num], color_back, color_wave, z) # WS 波形番号を表示する text = f'WS{ymf825.Voice_Op_Edit[WS][OP_num]:>2}' zs = [250, 180 +36] chr_num = len(text) color_text = PURPLE dsp_text_bar(text, zs, chr_num, color_back, color_text) # edit ADSR 編集 # OP_num は、変更されて返ってくることを前提にする # 2025/11/03 ymf825.Voice_Op_Edit[MUL][OP_num] を追加、表示のみ OP_num_old = OP_num tabM_num_old = tabM_num (tabM_num, tabL[tabM_num_old], OP_num, ymf825.Voice_Op_Edit[TL][OP_num_old], \ ymf825.Voice_Op_Edit[SL][OP_num_old], ymf825.Voice_Op_Edit[AR][OP_num_old], \ ymf825.Voice_Op_Edit[DR][OP_num_old], ymf825.Voice_Op_Edit[SR][OP_num_old], \ ymf825.Voice_Op_Edit[RR][OP_num_old], ymf825.Voice_Op_Edit[KSL][OP_num_old], \ ymf825.Voice_Op_Edit[KSR][OP_num_old]) = \ edit_adsr(tabM_num, tabL[tabM_num], OP_num, ymf825.Voice_Op_Edit[TL][OP_num], \ ymf825.Voice_Op_Edit[SL][OP_num], ymf825.Voice_Op_Edit[AR][OP_num], \ ymf825.Voice_Op_Edit[DR][OP_num], ymf825.Voice_Op_Edit[SR][OP_num], \ ymf825.Voice_Op_Edit[RR][OP_num], ymf825.Voice_Op_Edit[KSL][OP_num], \ ymf825.Voice_Op_Edit[KSR][OP_num], ymf825.Voice_Op_Edit[MUL][OP_num]) processMsg = '[ADSR] Edit end' print(processMsg) elif tabL[tabM_num] == tabDAM: print(f'tab[DAM] was selected') # tabOP が選択されたら、選択されている getTN tone_name ALG を上段に表示する dsp_ALG_TN(ymf825.Voice_Com_Edit[ALG][CM1], OP_num, getTN, ymf825.ToneName[getTN]) # edit DAM EAM DVB EVB 編集 # OP_num は、変更されて返ってくることを前提にする OP_num_old = OP_num tabM_num_old = tabM_num (tabM_num, tabL[tabM_num_old], OP_num, ymf825.Voice_Op_Edit[DAM][OP_num_old], \ ymf825.Voice_Op_Edit[EAM][OP_num_old],ymf825.Voice_Op_Edit[DVB][OP_num_old], \ ymf825.Voice_Op_Edit[EVB][OP_num_old]) = \ edit_dam(tabM_num, tabL[tabM_num], OP_num, ymf825.Voice_Op_Edit[DAM][OP_num], \ ymf825.Voice_Op_Edit[EAM][OP_num], ymf825.Voice_Op_Edit[DVB][OP_num], \ ymf825.Voice_Op_Edit[EVB][OP_num]) processMsg = '[DAM] Edit end' print(processMsg) else: tabM_num_old = tabM_num (tabM_num, tabL[tabM_num_old]) = select_SubMenu(tabM_num, tabL[tabM_num]) processMsg = '' ######################################################################## print(f'main Loop tab[OP] end ... gc.mem_alloc() = {gc.mem_alloc()}') ######################################################################## elif tabM_num == tabPUT: print(f'tab[PUT] was selected') if tabL[tabM_num] == tabYMF: print(f"tab[YMF]:PicoSub's device YMF825 was selected") # getTN（Tone Number）選択 guide_msg1 = 'Get Tone Data' guide_msg2 = 'Select Tone Number' putTN = getTN putTN_old = putTN # (btn, putTN) = select_ToneNumber(guide_msg, putTN_old) tabM_num_old = tabM_num (tabM_num, tabL[tabM_num_old], btn, putTN) = \ select_ToneNumber(tabM_num, tabL[tabM_num], guide_msg1, guide_msg2, \ putTN_old, ymf825.ToneName) if putTN_old != putTN: print(f'Tone Number has changed') if btn == 'Execute': print(f'Execution Put Tone Data') # ToneVoice をシリアル出力（プリント） ymf825.serialOutVoiceData(putTN) # 編集した内容を Tone Data に保存 ymf825.copyVoice2_Tone(putTN) #################################################################### # getTN で指定された Tone_Com_Edit と Tone_Op_Edit を # PicoSub の putTN で指定された Tone_Com_Edit と Tone_Op_Edit に保存する setToneDataPicoSub(getTN, putTN) #################################################################### processMsg = 'Succeed [YMF] WR' print(processMsg) # main Menu 選択に移行 tabM_num = 0 elif btn == 'Cancel': print('Cansel was selected') # subMenu をリセット tabL[tabM_num] = 0 # main Menu 選択に移行 tabM_num = 0 # tabM_num or tabL[tabM_num] was Changed else: print('Tab was Changed') dspFillUpper(WHITE) elif tabL[tabM_num] == tabSD: print(f'tab[SD]:card was selected') # SD-CARD に書き込む ファイル名は ymf825.ToneName に登録されているものを編集する。 # 15文字以下で、末尾の余白を取り除いたものにファイルの拡張子は「.txt」を付加する。 # file name 入力 loop = 1 # 正常処理が終われば flag_loop = 0 として書き込み動作に移る while loop == 1: digit_max = 15 # tone_name の最大桁数 exeName = ' OK ' tone_name = ymf825.ToneName[getTN] print(f'tone_name = {tone_name}') tone_name_old = tone_name tabM_num_old = tabM_num # (btn, tone_name) = edit_ToneName(tone_name_old, digit_max, exeName) (tabM_num, tabL[tabM_num_old], btn, tone_name) = \ edit_ToneName(tabM_num, tabL[tabM_num], tone_name_old, digit_max, exeName) if tone_name_old != tone_name: print(f'Tone Name has changed') print(f'tone_name = {tone_name}') if btn == exeName or btn == 'Enter': print(f'Execution Put Tone Data') # Tone Name 更新 ymf825.ToneName[getTN] = tone_name.strip() # 末尾のスペースを取り除く # ToneVoice をシリアル出力（プリント） ymf825.serialOutVoiceData(putTN) # 編集した内容を Tone Data に保存 ymf825.copyVoice2_Tone(putTN) # Tone_Com_Edit, Tone_Op_Edit を ASCII２文字の send_buffに変換 # puTNの指定（=Tone Number）の変更はなしとするので # ymf825.takeOutToneData2(getTN, putTN) は使用しない。 # Tone Number は、読み込むときに指定すれば良い。 ymf825.takeOutToneData(getTN) # file_name 生成 file_name = tone_name.strip()+'.txt' file_path = '/sd/'+file_name print(f'file_path = {file_path}') if file_name in os.listdir('/sd'): # 同じファイル名が存在すれば上書きするか確認のステップを入れる print('########################################################') print(f'The file name ({file_name}) exist on the SD card.') print('########################################################') # 上書きするか否か title = 'File name exists' guide1 = 'Want to OverWrite?' guide2 = 'Execute or Cancel' btn = select_CanExe(title, guide1, guide2) if btn == 'Execute': # while loop を抜けて書き込み実行 loop = 0 else: # file name = ToneName の再入力をするなら、while loop continue else: # 同じファイル名でなければ、while loop を抜けて書き込み実行 loop = 0 elif btn == 'Cancel': # edit_ToneName() で Cancel 選択ならば processMsg = 'Cansel SDcard WR' print(processMsg) print('Cansel was selected') # subMenu をリセット tabL[tabM_num] = 0 # main Menu 選択に移行 tabM_num = 0 break # tabM_num or tabL[tabM_num] was Changed else: print('Tab was Changed') dspFillUpper(WHITE) break else: # while loop の外である。loop == 0 でここに来る 書き込み実行 with open(file_path, 'w') as f: f.write(ymf825.send_buff) processMsg = 'Succeed SDcard WR' print(processMsg) # main Menu 選択に移行 tabM_num = 0 # DEBUG print("Files on filesystem:") print("====================") print_directory("/sd") file_list = sd_file_list("/sd") print() print(f'file_list = {file_list}') # DEBUG 書き込み具合を見たいとき・・・SDカードが見られる状態にするにはここで break # break # break ならば ここに来る edit_ToneName() で Cancel 選択ならば elif tabL[tabM_num] == tabMODE: print(f'tab[MODE]:YMF825 Play Mode was selected') # PicoSub YMF825 のMIDI再生モードを指定する。 # 15文字以下で、再生コマンドを用意して、PicoSub と共有する。 # mode_list にモードリストを用意しておき、選択して PicoSub に送る。 guide1 = 'Set Play Mode' guide2 = 'Select Play Mode' list_name = 'Play Mode' # list を表示、 ひとつを選択する # btn, play_mode = select_File(mode_list, guide1, guide2, list_name) tabM_num_old = tabM_num (tabM_num, tabL[tabM_num_old], btn, play_mode) = \ select_Item(tabM_num, tabL[tabM_num], mode_list, guide1, guide2, list_name) print() print(f'play_mode = {play_mode}') if btn == 'Execute': # plat_mode が 'Swapping_Ch0>' ならば、末尾にスワッピング・チャンネルを追加 if 'Swap'.lower() in play_mode.lower() and 'Ch0>'.lower() in play_mode.lower(): # tone_number を指定して取り込む # getTN（Tone Number）選択 guide_msg1 = 'Select Swapping Ch' guide_msg2 = 'Ch0 Swap to Ch?' default_ch = 14 tabM_num_old = tabM_num (tabM_num, tabL[tabM_num_old], btn, sw_ch) = \ select_SwapCh(tabM_num, tabL[tabM_num], guide_msg1, guide_msg2, \ default_ch) if btn == 'Execute': print(f'Selected Swap Ch0 to Ch{sw_ch}') # 指定された play_mode を PicoSub への送信データに構成する # 先頭の '2' は Play Mode であることを示す # 先頭に '2' に続けて play_mode を入れ、末尾にスペースを入れて16桁にする # play_mode = '2' + moji.strFixL_n(play_mode, 15) play_mode += str(sw_ch) print(f'play_mode = {play_mode}') play_mode = f'2{play_mode:<15}' print(f'setPlayModePicoSub play_mode = {play_mode}') ####################################################### setPlayModePicoSub(play_mode) ####################################################### # main Menu 選択に移行 tabM_num = 0 elif btn == 'Cancel': # select_ToneNumber で btn == 'Cancel' processMsg = 'Cansel Play Mode Set' print(processMsg) # subMenu をリセット tabL[tabM_num] = 0 # main Menu 選択に移行 tabM_num = 0 # tabM_num or tabL[tabM_num] was Changed else: print('Tab was Changed') else: # 指定された play_mode を PicoSub への送信データに構成する # 先頭の '2' は Play Mode であることを示す # 先頭に '2' に続けて play_mode を入れ、末尾にスペースを入れて16桁にする # play_mode = '2' + moji.strFixL_n(play_mode, 15) play_mode = f'2{play_mode:<15}' print(f'setPlayModePicoSub play_mode = {play_mode}') ####################################################### setPlayModePicoSub(play_mode) ####################################################### processMsg = 'SucceedSetPlayMode' print(processMsg) # main Menu 選択に移行 tabM_num = 0 elif btn == 'Cancel': processMsg = 'Cansel SetPlayMode' print(processMsg) # subMenu をリセット tabL[tabM_num] = 0 # main Menu 選択に移行 tabM_num = 0 # tabM_num or tabL[tabM_num] was Changed else: print('Tab was Changed') dspFillUpper(WHITE) else: dspFillUpper(WHITE) tabS_num = 0 tabM_num_old = tabM_num (tabM_num, tabL[tabM_num_old]) = select_SubMenu(tabM_num, tabS_num) processMsg = '' ######################################################################## print(f'main Loop tab[PUT] end ... gc.mem_alloc() = {gc.mem_alloc()}') ######################################################################## else: print(f'Nothing Selected main-tab') print(f'Before tabM_num = {tabM_num} tabL[tabM_num] = {tabL[tabM_num]}') # while tabM_num == 0 or tabL[tabM_num] == 0: # tabM_num_old = tabM_num # (tabM_num, tabL[tabM_num_old]) = edit_menu(tabM_num, tabL[tabM_num], processMsg) # 20251023 Change tabM_num = select_MainMenu(tabM_num, processMsg) print(f'After tabM_num = {tabM_num} tabL[tabM_num] = {tabL[tabM_num]}') ######################################################################## print(f'main MicroPython while ... gc.mem_alloc() = {gc.mem_alloc()}') ######################################################################## processMsg = '' ``` ### tone_edit.py ```MicroPython:tone_edit.py ######################################################################## # 2025/11/10 Programed by Hyodot # tone_edit_yyyymmdd-hhmm.py # LCDタッチパネル WAVE SHARE Pico-ResTouch-LCD-3.5 を利用した # PicoM_YMF825Edit.py # で使用する YMF825用のパラメータ編集用の関数群である。 ######################################################################## # 2025/08/02 : ADSRの表示と入力、WSの表示、ALGの表示まで完成させた # main_YMF825_PicoM-047_AdsrTest.py # から分離編集したものである。 # # WAVE SHARE Pico-ResTouch-LCD-3.5 で用意された main_3inch5.py を改良した # touch_lcd.py # および、表示座標を保存提供する # tab_cdn.py # を必要とする # # 2025/08/14：Pimoroni Pico Pi Plus 2 PSRAM 8MB を利用する # # ######################################################################## import math from micropython import const import time from touch_lcd import LCD_3inch5 from tab_cdn import TabCoordinate # タッチの誤動作を防止するためゾーンを複数回タッチした時に反応するようにした。 # ここで設定した回数を連続して検知した時に受け付ける。 TOUCH_TH = const(3) # この Pixel 分を上下左右に拡大したエリアをタッチ有効とする # 周辺部分では誤差が多いので、一部、この倍の領域にしている TOUCH = const(8) # 下半分表示の座標開始位置・・・この値は、ADSR 関連の関数で参照する ADSRxs = const(50) # x_start 30 ADSRys = const(270) # y_start # TAB 関連 TabCoordinate と同じもの Item = const(5) Mxs = const(0) Mys = const(0) Sxs = const(0) Sys = const(240) UPys = const(24) LWys = const(264) UPzs = [0, UPys] LWzs = [0, LWys] chr_n = const(4) # タブの文字数 chr_w = const(16) # 文字幅 chr_h = const(16) # 文字高さ txt_h = const(20) # 余白を含めた文字高さ xbt = const(4) # 縦線幅 x ybt = const(4) # 横線幅 y # tab の位置 tabGET = const(1) tabCOM = const(2) tabOP = const(3) tabPUT = const(4) tabALG = const(1) tabBO = const(2) tabLOF = const(3) tabWS = const(1) tabMUL = const(2) tabADSR = const(3) tabDAM = const(4) # YMF825 Grand Piano Tone Data Set # ToneNo 0-15 TN = 0 max_TN = const(15) # Common BO = 0 LFO = 1 ALG = 3 max_BO = const(3) max_LFO = const(3) max_ALG = const(7) # Operator # 以下は、オペレーション・パラメータで、それぞれ４つのオペレータがある。 # 0:Max,op1,op2,op3,op4 を OP_numで指定する。 # 0:Max 1 2 3 4 WS = [31, 8, 0, 0, 0] MUL = [15, 1, 5, 1, 1] DT = [ 7, 0, 0, 0, 0] FB = [ 7, 0, 0, 0, 0] XOF = [ 1, 0, 0, 0, 0] TL = [63,39,40,34, 0] SL = [15,15, 2, 3, 4] AR = [15,15,14,13,13] DR = [15, 7, 3, 1, 2] SR = [15, 0, 2, 1, 2] RR = [15, 6, 3, 4, 6] KSL = [ 3, 1, 3, 0, 2] KSR = [ 1, 0, 1, 0, 1] DAM = [ 3, 0, 0, 0, 0] EAM = [ 1, 0, 0, 0, 0] DVB = [ 3, 0, 0, 0, 0] EVB = [ 1, 0, 0, 1, 1] OP_num = 1 OP_max = const(0) max_WS = WS[OP_max] max_MUL = MUL[OP_max] max_DT = DT[OP_max] max_FB = FB[OP_max] max_XOF = XOF[OP_max] max_TL = TL[OP_max] -15 # YMF825 は 63 だが 実用的に 48 とする max_SL = SL[OP_max] max_AR = AR[OP_max] max_DR = DR[OP_max] max_SR = SR[OP_max] max_RR = RR[OP_max] max_KSL = KSL[OP_max] max_KSR = KSR[OP_max] max_DAM = DAM[OP_max] max_EAM = EAM[OP_max] max_DVB = DVB[OP_max] max_EVB = EVB[OP_max] # MF825_PicoM-047.py より移植 # BO, LOF, MUL, FB, XOF, DAM EAM, DVB, EVB タッチ座標の提供 # BO タッチ開始座標の設定 # 0 1 2 3 BOxs = [ 32, 32, 32, 32] # BOys = [190,170,150,130] BOys = [240+190, 240+170, 240+150, 240+130] BOcn = 5 # LFO タッチ開始座標の設定 # 0 1 2 3 LFOxs = [192,192,192,192] # LFOys = [190,170,150,130] LFOys = [240+190, 240+170, 240+150, 240+130] LFOcn = 5 # sign_XX は、スライダーの正負（X軸、Y軸の移動に対して取得数値が増大か？縮小か？） # MUL DT ともに上が大、下が小なので、-1 sign_MUL = -1 sign_DT = -1 # FB タッチ開始座標の設定 # 0 1 2 3 4 5 6 7 FBxs = [160,160,160,160,160,160,160,160] FBys = [430,410,390,370,350,330,310,290] FBcn = 5 # XOF タッチ開始座標の設定 # 0 1 XOFxs = [250,250] XOFys = [430,410] XOFcn = 3 # DAM タッチ開始座標の設定 # 0 1 2 3 DAMxs = [ 32, 32, 32, 32] DAMys = [350,330,310,290] DAMcn = 6 # DVB タッチ開始座標の設定 # 0 1 2 3 DVBxs = [192,192,192,192] DVBys = [350,330,310,290] DVBcn = 6 # EAM タッチ開始座標の設定 # 0 1 EAMxs = [ 32, 32] EAMys = [430,410] EAMcn = 6 # EVB タッチ開始座標の設定 # 0 1 EVBxs = [192,192] EVBys = [430,410] EVBcn = 6 # TN タッチ開始座標の設定 # 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 TNxs = [ 64,112,160,208, 64,112,160,208, 64,112,160,208, 64,112,160,208] TNys = [390,390,390,390,360,360,360,360,330,330,330,330,300,300,300,300] TNcn = 3 # Full Key タッチ開始座標の設定 FKxb = const(0) # FKyb = const(266) FKyb = const(268 +20) FKcw = const(32) FKch = const(32) key_c = const(10) key_r = const(6) FKxs = [None] *key_c for i in range(key_c): FKxs[i] = i *FKcw # 0 1 2 3 4 5 6 7 8 9 # FKxs = [ 0, 32, 64, 96,128,160,192,224,256,288] FKys = [None] *key_r for i in range(key_r): # FKys[i] = i *FKch + 268 +20 FKys[i] = i *FKch +FKyb # 0 1 2 3 4 5 # FKys = [288,320,352,384,416,448] # Full Key タッチゾーンの設定 zone_FKs = [None, None] *key_c zone_FKe = [None, None] *key_c for i in range(key_c): zone_FKs[i] = [None] *key_r zone_FKe[i] = [None] *key_r for x in range(key_c): for y in range(key_r): zone_FKs[x][y] = [FKxs[x], FKys[y]] zone_FKe[x][y] = [FKxs[x]+FKcw, FKys[y]+FKch] # FKs[0][0]=[ 0,288] FKs[0][1]=[ 0,320] FKs[0][2]=[ 0,352] ... FKs[0][4]=[ 0,416] FKs[0][5]=[ 0,448] # FKs[1][0]=[32,288] FKs[1][1]=[32,320] FKs[1][2]=[32,352] ... FKs[1][4]=[32,416] FKs[1][5]=[32,448] # ・・・ # FKs[9][0]=[288,288] FKs[9][1]=[288,320] FKs[9][2]=[288,352] ... FKs[9][4]=[288,416] FKs[9][5]=[288,448] # No Shift ★★★ FKv0[FKy, FKx] ・・・ X軸、Y軸を入れ替えて指定すること FKv0 = [ # 0 1 2 3 4 5 6 7 8 9 ['!', '"', '#', '$', '%', '&', "'", '(', ')', ' '], ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0'], ['q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p'], ['a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', ' '], ['z', 'x', 'c', 'v', 'b', 'n', 'm', ';', ':', ' '], [' ', ' ', ' ', ' ', ',', '.', '/', '|', '^', '|'] ] # Shift ★★★ FKv1[FKy, FKx] ・・・ X軸、Y軸を入れ替えて指定すること FKv1 = [ # 0 1 2 3 4 5 6 7 8 9 ['@', '+', '*', '-', '=', '{', "}", '[', ']', ' '], ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0'], ['Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P'], ['A', 'S', 'D', 'F', 'G', 'H', 'J', 'K', 'L', ' '], ['Z', 'X', 'C', 'V', 'B', 'N', 'M', '+', '*', ' '], [' ', ' ', ' ', ' ', '<', '>', '?', '_', '~', '|'] ] ################################################## # import した ライブラリ class の短縮名 LCD = LCD_3inch5() LCD.bl_ctrl(100) print(f'LCD.rotate = {LCD.rotate}') TAB = TabCoordinate() ################################################## # main program から LCD_3inch5 が実行できるように def spi_change2_lcd(): LCD.spi_change2_lcd() def dspFill(color): LCD.fill(color) def dspFill_rect(zs, w, h, color_back): LCD.fill_rect(zs[0], zs[1], w, h, color_back) def clearMainTab(color_back): LCD.fill_rect(0, 0, 320, 24, color_back) def clearSubTab(color_back): LCD.fill_rect(0,240, 320, 24, color_back) def dspFillUpper(color_back): (zs, w, h) = TAB.get_UpperAria() LCD.fill_rect(zs[0], zs[1], w, h, color_back) def dspFillLower(color_back): (zs, w, h) = TAB.get_LowerAria() LCD.fill_rect(zs[0], zs[1], w, h, color_back) def dspShow(): LCD.show() def dspColorlist(): return [LCD.BLACK, LCD.RED, LCD.GREEN, LCD.BLUE, LCD.YELLOW,\ LCD.PURPLE, LCD.BLUEGREEN, LCD.GRAY, LCD.WHITE] # X_Poin と Y_Point が 共に zoneS ~ zoneE の範囲内にあるか否か def in_zone(zoneS, zoneE, X_Point, Y_Point): if zoneS[0] <= X_Point and X_Point <= zoneE[0] \ and zoneS[1] <= Y_Point and Y_Point <= zoneE[1]: # X_Poin と Y_Point が 共に zoneS ~ zoneE の範囲内ならば True return True else: return False ######################################################################################## # 表示関係の関数 def select_main_tab(tabM_num): # Main Tab の座標リストを取得 zoneMtab_s = TAB.get_zoneMtab_s() zoneMtab_e = TAB.get_zoneMtab_e() tabMain_text = TAB.get_tabMain_text() cnt_zone = [0, 0, 0, 0, 0] # zone0, zone1, zone2, zone3, zone4 # tabM_num != 0 で終了 while tabM_num == 0: get = LCD.touch_get() if get != None: # タッチされているなら X_Point = get[0] Y_Point = get[1] for i in range(1, Item): if in_zone(zoneMtab_s[i], zoneMtab_e[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば # print(f'select zoneMtab[{i}]') cnt_zone[i] += 1 if cnt_zone[i] == TOUCH_TH: tabM_num = i print(f'main tab = {tabMain_text[tabM_num]}') else: time.sleep_ms(50) return tabM_num def select_SubCom_tab(tabM_num, tabS_num): # Main Tab の座標リストを取得 zoneMtab_s = TAB.get_zoneMtab_s() zoneMtab_e = TAB.get_zoneMtab_e() tabMain_text = TAB.get_tabMain_text() cntM_zone = [0, 0, 0, 0, 0] # zone0, zone1, zone2, zone3, zone4 # Sub Tab の座標リストを取得 zoneStab_s = TAB.get_zoneStab_s() zoneStab_e = TAB.get_zoneStab_e() tabCOM_text = TAB.get_tabCOM_text() cntS_zone = [0, 0, 0, 0, 0] # zone0, zone1, zone2, zone3, zone4 tabM_num_old = tabM_num # tabM_num_old != tabM_num または tabM_num != 0 で終了 while tabM_num_old == tabM_num and tabS_num == 0: get = LCD.touch_get() if get != None: # タッチされているなら X_Point = get[0] Y_Point = get[1] for i in range(1, Item): if in_zone(zoneMtab_s[i], zoneMtab_e[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば # print(f'select zoneMtab[{i}]') cntM_zone[i] += 1 if cntM_zone[i] == TOUCH_TH: tabM_num = i print(f'main tab = {tabMain_text[tabM_num]}') for i in range(1, Item -1): # ALG BO LFO の３つ if in_zone(zoneStab_s[i], zoneStab_e[i], X_Point, Y_Point): # zoneStab[i] の周辺ならば # print(f'select zoneStab[{i}]') cntS_zone[i] += 1 if cntS_zone[i] == TOUCH_TH: tabS_num = i print(f'sub tab = {tabCOM_text[tabS_num]}') else: time.sleep_ms(50) return tabM_num, tabS_num def select_SubOp_tab(tabM_num, tabS_num): # Main Tab の座標リストを取得 zoneMtab_s = TAB.get_zoneMtab_s() zoneMtab_e = TAB.get_zoneMtab_e() tabMain_text = TAB.get_tabMain_text() cntM_zone = [0, 0, 0, 0, 0] # zoneM0, zoneM1, zoneM2, zoneM3, zoneM4 # Sub Tab の座標リストを取得 zoneStab_s = TAB.get_zoneStab_s() zoneStab_e = TAB.get_zoneStab_e() tabOP_text = TAB.get_tabOP_text() cntS_zone = [0, 0, 0, 0, 0] # zoneS0, zoneS1, zoneS2, zoneS3, zoneS4 tabM_num_old = tabM_num # tabM_num_old != tabM_num または tabM_num != 0 で終了 while tabM_num_old == tabM_num and tabS_num == 0: get = LCD.touch_get() if get != None: # タッチされているなら X_Point = get[0] Y_Point = get[1] for i in range(1, Item): if in_zone(zoneMtab_s[i], zoneMtab_e[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば # print(f'select zoneMtab[{i}]') cntM_zone[i] += 1 if cntM_zone[i] == TOUCH_TH: tabM_num = i print(f'main tab = {tabMain_text[tabM_num]}') for i in range(1, Item): # WS MUL ADSR DAM の４つ if in_zone(zoneStab_s[i], zoneStab_e[i], X_Point, Y_Point): # zoneStab[i] の周辺ならば # print(f'select zoneStab[{i}]') cntS_zone[i] += 1 if cntS_zone[i] == TOUCH_TH: tabS_num = i print(f'sub tab = {tabOP_text[tabS_num]}') else: time.sleep_ms(50) return tabM_num, tabS_num def select_SubGet_tab(tabM_num, tabS_num): # Main Tab の座標リストを取得 zoneMtab_s = TAB.get_zoneMtab_s() zoneMtab_e = TAB.get_zoneMtab_e() tabMain_text = TAB.get_tabMain_text() cntM_zone = [0, 0, 0, 0, 0] # zoneM0, zoneM1, zoneM2, zoneM3, zoneM4 # Sub Tab の座標リストを取得 zoneStab_s = TAB.get_zoneStab_s() zoneStab_e = TAB.get_zoneStab_e() tabGET_text = TAB.get_tabOP_text() cntS_zone = [0, 0, 0, 0, 0] # zoneS0, zoneS1, zoneS2, zoneS3, zoneS4 tabM_num_old = tabM_num # tabM_num_old != tabM_num または tabM_num != 0 で終了 while tabM_num_old == tabM_num and tabS_num == 0: get = LCD.touch_get() if get != None: # タッチされているなら X_Point = get[0] Y_Point = get[1] for i in range(1, Item): if in_zone(zoneMtab_s[i], zoneMtab_e[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば # print(f'select zoneMtab[{i}]') cntM_zone[i] += 1 if cntM_zone[i] == TOUCH_TH: tabM_num = i print(f'main tab = {tabMain_text[tabM_num]}') for i in range(1, Item): # Edit, Rfid, Orig の３つ if in_zone(zoneStab_s[i], zoneStab_e[i], X_Point, Y_Point): # zoneStab[i] の周辺ならば # print(f'select zoneStab[{i}]') cntS_zone[i] += 1 if cntS_zone[i] >= TOUCH_TH: tabS_num = i print(f'sub tab = {tabGET_text[tabS_num]}') else: time.sleep_ms(50) return tabM_num, tabS_num def select_SubPut_tab(tabM_num, tabS_num): # Main Tab の座標リストを取得 zoneMtab_s = TAB.get_zoneMtab_s() zoneMtab_e = TAB.get_zoneMtab_e() tabMain_text = TAB.get_tabMain_text() cntM_zone = [0, 0, 0, 0, 0] # zoneM0, zoneM1, zoneM2, zoneM3, zoneM4 # Sub Tab の座標リストを取得 zoneStab_s = TAB.get_zoneStab_s() zoneStab_e = TAB.get_zoneStab_e() tabPUT_text = TAB.get_tabOP_text() cntS_zone = [0, 0, 0, 0, 0] # zoneS0, zoneS1, zoneS2, zoneS3, zoneS4 tabM_num_old = tabM_num # tabM_num_old != tabM_num または tabM_num != 0 で終了 while tabM_num_old == tabM_num and tabS_num == 0: get = LCD.touch_get() if get != None: # タッチされているなら X_Point = get[0] Y_Point = get[1] for i in range(1, Item): if in_zone(zoneMtab_s[i], zoneMtab_e[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば # print(f'select zoneMtab[{i}]') cntM_zone[i] += 1 if cntM_zone[i] == TOUCH_TH: tabM_num = i print(f'main tab = {tabMain_text[tabM_num]}') for i in range(1, Item): # Edit, Rfid の２つ if in_zone(zoneStab_s[i], zoneStab_e[i], X_Point, Y_Point): # zoneStab[i] の周辺ならば # print(f'select zoneStab[{i}]') cntS_zone[i] += 1 if cntS_zone[i] == TOUCH_TH: tabS_num = i print(f'sub tab = {tabPUT_text[tabS_num]}') else: time.sleep_ms(50) return tabM_num, tabS_num # 指定された 開始座標 zs から width, height, 太さ xbt # color_lineで指定された枠、color_backで指定された背景色を表示する。 # 中のテキスト行は、dsp_text_bar(text, zs, chr_num, color_back, color_text) を使う。 # 行は 20 Pixel単位、文字は 16 Pixel 単位になる def dsp_WindowFrame(zs, width, height, color_line, color_back): # zs: WindowFrame の開始座標 # xbt = 4 # line X 縦線の太さ（pixel数） # ybt = 4 # line Y 横線の太さ（pixel数） # 大きな四角の内側に小さな四角を描き、差分を枠線として表示する # zx zy w h color_line LCD.fill_rect(zs[0] , zs[1], width, height, color_line) LCD.fill_rect(zs[0] +xbt, zs[1] +ybt, width -xbt *2, height -ybt *2, color_back) # 指定された開始座標の内側に 背景と テキストを表示する ・・・ chr_num を指定する汎用タイプ # 20 Pixel 毎に行を構成することを前提 def dsp_text_bar(text, zs, chr_num, color_back, color_text): # zs: 開始座標 # chr_num: テキスト の文字幅 # chr_w = 16 # chr_h = 16 xbt2 = 2 # 文字背景の X 周囲（pixel数） ybt2 = 2 # 文字背景の X 周囲（pixel数） LCD.fill_rect(zs[0], zs[1], chr_w *chr_num +xbt2*2, chr_h +ybt2*2, color_back) LCD.text_scaled(text,zs[0] +xbt2, zs[1] +ybt2, color_text, 2) # 指定された開始座標の内側に 背景と テキストを表示して末尾の次にカーソルを表示する # 20 Pixel 毎に行を構成することを前提に、編集中の文字表示とカーソル表示をする def dsp_text_cursor(text, zs, chr_num, color_back, color_text, blink = 0): # text 編集中の文字 # zs: 開始座標 # chr_num: テキスト の文字幅 ・・・ 表示バーは +1 # chr_w = 16 # chr_h = 16 xbt2 = 2 # 文字背景の X 周囲（pixel数） ybt2 = 2 # 文字背景の X 周囲（pixel数） LCD.fill_rect(zs[0], zs[1], chr_w *(chr_num +1) +xbt2*2, chr_h +ybt2*2, color_back) # len(text) == 0 だとエラーになるのを回避するため スペースを表示する if len(text) > 0: LCD.text_scaled(text, zs[0] +xbt2, zs[1] +ybt2, color_text, 2) else: LCD.text_scaled(' ', zs[0] +xbt2, zs[1] +ybt2, color_text, 2) # カーソル表示 文字領域の左端 2 Pixel if blink == 0: LCD.fill_rect(zs[0] +chr_w *len(text) +xbt2, zs[1] +ybt2, xbt2*2, chr_h, LCD.BLACK) else: LCD.fill_rect(zs[0] +chr_w *len(text) +xbt2, zs[1] +ybt2, xbt2*2, chr_h, LCD.GRAY) # テキスト表示の外側に四角の枠を描き、中にテキストを表示する ・・・ chr_num を指定する汎用タイプ def dsp_text_frame(text, zs, chr_num, color_line, color_back, color_text): # zs:テキスト表示開始座標 # chr_num: テキスト の文字幅 # chr_w = 16 # chr_h = 16 # xbt = 4 # line X 縦線の太さ（pixel数） # ybt = 4 # line Y 横線の太さ（pixel数） # ZS 範囲外を是正 zs[0] = xbt *2 if zs[0] < xbt *2 else zs[0] zs[1] = ybt *2 if zs[1] < ybt *2 else zs[1] # 大きな四角の内側に少し小さな四角を描き、差分を枠線として表示する LCD.fill_rect(zs[0] -xbt*2, zs[1] -ybt*2, chr_w *chr_num +xbt*4, chr_h +ybt*4, color_line) LCD.fill_rect(zs[0] -xbt*1, zs[1] -ybt*1, chr_w *chr_num +xbt*2, chr_h +ybt*2, color_back) LCD.text_scaled(text,zs[0], zs[1], color_text, 2) # タブ の四角の枠とタブの名前を表示する ・・・ main-menu と sub-menu 表示に特化 def dsp_tab(tab_name, zs, color_line, color_back, color_text): # zs:TAB LABEL 開始座標 = 大きな外枠の開始座標 # 大きな四角の内側に小さな四角を描き、差分を枠線として表示する LCD.fill_rect(zs[0], zs[1], chr_w *chr_n +xbt*2, chr_h +ybt*2, color_line) LCD.fill_rect(zs[0] +xbt, zs[1] +ybt, chr_w *chr_n, chr_h, color_back) LCD.text_scaled(tab_name, zs[0] +xbt, zs[1] +ybt, color_text, 2) # main menu def dsp_menu_main(tabM_num): # Main Tab の座標リストを取得 zoneMtab_s = TAB.get_zoneMtab_s() zoneMtab_e = TAB.get_zoneMtab_e() tabMain_text = TAB.get_tabMain_text() # Main Tab エリアのみ消去 # LCD.fill_rect(0, 0, 320, 24, LCD.BLACK) clearMainTab(LCD.BLACK) # Non High Light for i in range(1, Item): dsp_tab(tabMain_text[i] , zoneMtab_s[i], LCD.BLUE, LCD.GREEN, LCD.BLACK) # High Light if tabM_num > 0 and tabM_num < Item: dsp_tab(tabMain_text[tabM_num] , zoneMtab_s[tabM_num], LCD.YELLOW, LCD.WHITE, LCD.RED) LCD.show() # op-sub-menu def dsp_menu_op(tabS_num): # Sub Tab の座標リストを取得 zoneStab_s = TAB.get_zoneStab_s() zoneStab_e = TAB.get_zoneStab_e() tabOP_text = TAB.get_tabOP_text() # Sub Tab エリアのみ消去 # LCD.fill_rect(0,240, 320, 24, LCD.BLACK) clearSubTab(LCD.BLACK) # Non High Light for i in range(1, Item): dsp_tab(tabOP_text[i] , zoneStab_s[i], LCD.BLUE, LCD.GREEN, LCD.BLACK) # High Light --- tabS_num 1:WS 2:MUL 3:ADSR 4:DAM if tabS_num > 0 and tabS_num < Item: dsp_tab(tabOP_text[tabS_num] , zoneStab_s[tabS_num], LCD.YELLOW, LCD.WHITE, LCD.RED) LCD.show() # get-sub-menu def dsp_menu_get(tabS_num): # Sub Tab の座標リストを取得 zoneStab_s = TAB.get_zoneStab_s() zoneStab_e = TAB.get_zoneStab_e() tabGET_text = TAB.get_tabGET_text() # Sub Tab エリアのみ消去 # LCD.fill_rect(0,240, 320, 24, LCD.BLACK) clearSubTab(LCD.BLACK) # Non High Light for i in range(1, Item): dsp_tab(tabGET_text[i] , zoneStab_s[i], LCD.BLUE, LCD.GREEN, LCD.BLACK) # High Light --- tabS_num 1:WS 2:MUL 3:ADSR 4:DAM if tabS_num > 0 and tabS_num < Item: dsp_tab(tabGET_text[tabS_num] , zoneStab_s[tabS_num], LCD.YELLOW, LCD.WHITE, LCD.RED) LCD.show() # put-sub-menu def dsp_menu_put(tabS_num): # Sub Tab の座標リストを取得 zoneStab_s = TAB.get_zoneStab_s() zoneStab_e = TAB.get_zoneStab_e() tabPUT_text = TAB.get_tabPUT_text() # Sub Tab エリアのみ消去 # LCD.fill_rect(0,240, 320, 24, LCD.BLACK) clearSubTab(LCD.BLACK) # Non High Light for i in range(1, Item): dsp_tab(tabPUT_text[i] , zoneStab_s[i], LCD.BLUE, LCD.GREEN, LCD.BLACK) # High Light --- tabS_num 1:WS 2:MUL 3:ADSR 4:DAM if tabS_num > 0 and tabS_num < Item: dsp_tab(tabPUT_text[tabS_num] , zoneStab_s[tabS_num], LCD.YELLOW, LCD.WHITE, LCD.RED) LCD.show() # com-sub-menu def dsp_menu_com(tabS_num): # Sub Tab の座標リストを取得 zoneStab_s = TAB.get_zoneStab_s() tabCOM_text = TAB.get_tabCOM_text() # Sub Tab エリアのみ消去 # LCD.fill_rect(0,240, 320, 24, LCD.BLACK) clearSubTab(LCD.BLACK) # Non High Light for i in range(1, Item): dsp_tab(tabCOM_text[i] , zoneStab_s[i], LCD.BLUE, LCD.GREEN, LCD.BLACK) # High Light --- tabS_num 1:ALG 2:BO 3:LFO if tabS_num > 0 and tabS_num < Item: dsp_tab(tabCOM_text[tabS_num] , zoneStab_s[tabS_num], LCD.YELLOW, LCD.WHITE, LCD.RED) LCD.show() def dsp_menu_sub(tabM_num, tabS_num): # Sub Tab の座標リストを取得 zoneStab_s = TAB.get_zoneStab_s() if tabM_num == 1: dsp_menu_get(tabS_num) elif tabM_num == 2: dsp_menu_com(tabS_num) elif tabM_num == 3: dsp_menu_op(tabS_num) elif tabM_num == 4: dsp_menu_put(tabS_num) else: # Sub Tab エリアのみ消去 # LCD.fill_rect(0,240, 320, 24, LCD.BLACK) clearSubTab(LCD.BLACK) # 無地で空欄を表示 for i in range(1, Item): dsp_tab(' ' , zoneStab_s[i], LCD.BLUE, LCD.GREEN, LCD.BLACK) LCD.show() # 20250914-2118 Change タブ表示のみ def dsp_menu(tabM_num, tabS_num): # 現在の設定内容を表示 dsp_menu_main(tabM_num) dsp_menu_sub(tabM_num, tabS_num) LCD.show() # タブ表示と不備なら編集 def edit_menu(tabM_num, tabS_num, processMsg = ''): # 現在の設定内容を表示 dsp_menu_main(tabM_num) dsp_menu_sub(tabM_num, tabS_num) # main-tab が設定されていない（tabM_num == 0）なら設定画面を表示し設定する while tabM_num == 0: dspFillUpper(LCD.WHITE) dspFillLower(LCD.WHITE) LCD.show() # display 'Select Main Tab' at the upper zs = [10, 60] text = processMsg chr_num = len(processMsg) if chr_num > 0: dsp_text_bar(text, zs, chr_num, LCD.YELLOW, LCD.RED) text = ' Select Main Tab !' chr_num = len(text) # text 表示開始座標を設定 zs = [None] *2 zs[0] = UPzs[0] +10 zs[1] = UPzs[1] +100 dsp_text_frame(text, zs, chr_num, LCD.RED, LCD.YELLOW, LCD.RED) LCD.show() (tabM_num) = select_main_tab(tabM_num) dspFillUpper(LCD.WHITE) LCD.show() # 現在の設定内容を表示 dsp_menu_main(tabM_num) dsp_menu_sub(tabM_num, tabS_num) tabM_num_old = tabM_num # sub-tab が設定されていない（tabS_num == 0）なら設定画面を表示し設定する # main_tab 変更も受け付ける while tabS_num == 0 and tabM_num_old == tabM_num: dspFillLower(LCD.WHITE) LCD.show() # display 'Select Sub Tab' at the lower text = ' Select Sub Tab !' chr_num = len(text) # text 表示開始座標を設定 zs = [None] *2 zs[0] = LWzs[0] +10 zs[1] = LWzs[1] +80 dsp_text_frame(text, zs, chr_num, LCD.RED, LCD.YELLOW, LCD.RED) LCD.show() if tabM_num == 1: (tabM_num, tabS_num) = select_SubGet_tab(tabM_num, tabS_num) elif tabM_num == 2: (tabM_num, tabS_num) = select_SubCom_tab(tabM_num, tabS_num) elif tabM_num == 3: (tabM_num, tabS_num) = select_SubOp_tab(tabM_num, tabS_num) elif tabM_num == 4: (tabM_num, tabS_num) = select_SubPut_tab(tabM_num, tabS_num) dspFillLower(LCD.WHITE) LCD.show() # 現在の設定内容を表示 dsp_menu_main(tabM_num) dsp_menu_sub(tabM_num, tabS_num) return (tabM_num, tabS_num) # tabM_num == 0 の時に実行させる def select_MainMenu(tabM_num, processMsg = ''): dspFillUpper(LCD.WHITE) dspFillLower(LCD.WHITE) text = processMsg chr_num = len(processMsg) if chr_num > 0: zs = [10, 60] dsp_text_bar(text, zs, chr_num, LCD.YELLOW, LCD.RED) # display 'Select Main Tab' at the upper text = ' Select Main Tab !' chr_num = len(text) # text 表示開始座標を設定 # zs = [None] *2 zs = [UPzs[0] +10, UPzs[1] +100] dsp_text_frame(text, zs, chr_num, LCD.RED, LCD.YELLOW, LCD.RED) LCD.show() # main-tab が設定されていない（tabM_num == 0）なら設定画面を表示し設定する while tabM_num == 0: # main tab の選択 (tabM_num) = select_main_tab(tabM_num) dspFillUpper(LCD.WHITE) LCD.show() # 現在の設定内容を表示 dsp_menu_main(tabM_num) # dsp_menu_sub(tabM_num, tabS_num) return tabM_num # tabS_num == 0 の時に実行させる def select_SubMenu(tabM_num, tabS_num): tabM_num_old = tabM_num # sub-tab が設定されていない（tabS_num == 0）なら設定画面を表示し設定する # main_tab 変更も受け付ける while tabS_num == 0 and tabM_num_old == tabM_num: dspFillLower(LCD.WHITE) text = ' Select Sub Tab !' chr_num = len(text) # text 表示開始座標を設定 zs = [None] *2 zs[0] = LWzs[0] +10 zs[1] = LWzs[1] +80 dsp_text_frame(text, zs, chr_num, LCD.RED, LCD.YELLOW, LCD.RED) LCD.show() if tabM_num == 1: (tabM_num, tabS_num) = select_SubGet_tab(tabM_num, tabS_num) elif tabM_num == 2: (tabM_num, tabS_num) = select_SubCom_tab(tabM_num, tabS_num) elif tabM_num == 3: (tabM_num, tabS_num) = select_SubOp_tab(tabM_num, tabS_num) elif tabM_num == 4: (tabM_num, tabS_num) = select_SubPut_tab(tabM_num, tabS_num) dspFillLower(LCD.WHITE) LCD.show() # 現在の設定内容を表示 dsp_menu_main(tabM_num) dsp_menu_sub(tabM_num, tabS_num) return tabM_num, tabS_num ######################################################################################## def dspWS(now_WS): xs = 0 ys = 264 # 240~259:[WS]Tab 260~263:Line w = 64 # セルの全体幅 h = 36 # セルの全体高さ zx = xs +w *4 # 256 zy = ys +h *5 # 444 tx = zx +16 ty = zy +10 # WS 数値表示 文字領域を 緑色にしてから表示 LCD.fill_rect(zx, zy, w, h, LCD.GREEN) LCD.text_scaled(f'{now_WS:>2}', tx, ty, LCD.PURPLE, 2) # AR TL SL DR SR RR の数値を表示する（編集中に再表示するので集約した） def dspAR(now_AR): # AR 数値表示 文字領域を 白色にしてから表示 LCD.fill_rect( 10,ADSRys+160,16*5,20, LCD.WHITE) LCD.text_scaled(f'AR:{now_AR}', 10,ADSRys+160,LCD.PURPLE, 2) def dspRR(now_RR): # RR 数値表示 文字領域を 白色にしてから表示 LCD.fill_rect(240,ADSRys+160,16*5,20, LCD.WHITE) LCD.text_scaled(f'RR:{now_RR}',240,ADSRys+160,LCD.PURPLE, 2) def dspTL(now_TL): # TL 数値表示 文字領域を 白色にしてから表示 LCD.fill_rect(120, ADSRys+180, 16*5,20, LCD.WHITE) LCD.text_scaled(f'TL:{now_TL}', 120, ADSRys+180,LCD.PURPLE, 2) def dspDR(now_DR): # DR 数値表示 文字領域を 白色にしてから表示 LCD.fill_rect(230, ADSRys+10,16*5,20, LCD.WHITE) LCD.text_scaled(f'DR:{now_DR}',230, ADSRys+10,LCD.PURPLE, 2) def dspSL(now_SL): # SL 数値表示 文字領域を 白色にしてから表示 LCD.fill_rect(230, ADSRys+30,16*5,20, LCD.WHITE) LCD.text_scaled(f'SL:{now_SL}',230, ADSRys+30,LCD.PURPLE, 2) def dspSR(now_SR): # SR 数値表示 文字領域を 白色にしてから表示 LCD.fill_rect(240, ADSRys+50,16*5,20, LCD.WHITE) LCD.text_scaled(f'SR:{now_SR}',240, ADSRys+50,LCD.PURPLE, 2) def dsp_KSL(now_KSL): # KSL 数値表示 背景を黄色にし、文字色は紫色 if now_KSL == 3: LCD.fill_rect(10,ADSRys+70,16*3,20, LCD.YELLOW) # KSL = 3 LCD.text_scaled(f'6.0', 10,ADSRys+70 +2,LCD.PURPLE, 2) # KSL=3 elif now_KSL == 1: LCD.fill_rect(10,ADSRys+90,16*3,20, LCD.YELLOW) # KSL = 1 LCD.text_scaled(f'3.0', 10,ADSRys+90 +2,LCD.PURPLE, 2) # KSL=1 elif now_KSL == 2: LCD.fill_rect(10,ADSRys+110,16*3,20, LCD.YELLOW) # KSL = 2 LCD.text_scaled(f'1.5', 10,ADSRys+110 +2,LCD.PURPLE, 2) # KSL=2 else: LCD.fill_rect(10,ADSRys+130,16*3,20, LCD.YELLOW) # KSL = 0 LCD.text_scaled(f'0.0', 10,ADSRys+130 +2,LCD.PURPLE, 2) # KSL=0 def dsp_KSR(now_KSR): # KSR 数値表示 背景を黄色にし、文字色は紫色 if now_KSR == 1: LCD.fill_rect(260,ADSRys+100,16*3,20, LCD.YELLOW) # KSR = 1 LCD.text_scaled(f'on ',260,ADSRys+100 +2,LCD.PURPLE, 2) # KSR=1 else: LCD.fill_rect(260,ADSRys+120,16*3,20, LCD.YELLOW) # KSR = 0 LCD.text_scaled(f'off',260,ADSRys+120 +2,LCD.PURPLE, 2) # KSR=0 # ADSR 編集画面に表示 def dspMUL2(now_MUL): # MUL 数値表示 文字領域を 白色にしてから表示 LCD.fill_rect(10, ADSRys +3, 16 *3, 20 *2, LCD.GRAY) LCD.text_scaled(f'MUL', 10, ADSRys +5, LCD.WHITE, 2) LCD.text_scaled(f'{now_MUL:>2}', 18, ADSRys +25, LCD.WHITE, 2) def dspMUL(now_MUL): # MUL 数値表示 文字領域を 白色にしてから表示 LCD.fill_rect(8, 270, 16*4, 20, LCD.WHITE) LCD.text_scaled(f'{now_MUL:>2}', 24, 270 +2, LCD.BLACK, 2) # 右寄せ表示 def dspDT(now_DT): # DT 数値表示 文字領域を 白色にしてから表示 # LCD.fill_rect(80+16, ys+70,16*3,20, LCD.WHITE) # LCD.text_scaled(f'{now_DT}', 80+24, ys+70+2, LCD.BLACK, 2) LCD.fill_rect(80+16, 340, 16*3, 20, LCD.WHITE) LCD.text_scaled(f'{now_DT}', 80+32, 340+2, LCD.BLACK, 2) def dsp_FB(now_FB, color_back, color_text): # FB 数値表示 背景を黄色にし、文字色は紫色 # 0 1 2 3 4 5 6 7 text_FB = [' 0 ', 'pi/16', 'pi/ 8', 'pi/ 4', 'pi/ 2', 'pi ', 'pi *2', 'pi *4'] if now_FB >= 0 and now_FB <= 7: # LCD.fill_rect(160-2, 430 -20*now_FB, 16*5 +4, 20, color_back) # LCD.text_scaled(text_FB[now_FB], 160, 430+2 -20*now_FB, color_text, 2) LCD.fill_rect(FBxs[now_FB]-2, FBys[now_FB], 16*FBcn +4, 20, color_back) LCD.text_scaled(text_FB[now_FB], FBxs[now_FB], FBys[now_FB]+2, color_text, 2) def dsp_XOF(now_XOF, color_back, color_text): # XOF 数値表示 背景を黄色にし、文字色は紫色 # 0 1 text_XOF = ['off', 'on '] if now_XOF >= 0 and now_XOF <= 1: # LCD.fill_rect(250-2, 430 -20*now_XOF, 16*3 +4, 20, color_back) # LCD.text_scaled(text_XOF[now_XOF], 250, 430+2 -20*now_XOF, color_text, 2) LCD.fill_rect(XOFxs[now_XOF]-2, XOFys[now_XOF], 16*XOFcn +4, 20, color_back) LCD.text_scaled(text_XOF[now_XOF], XOFxs[now_XOF], XOFys[now_XOF]+2, color_text, 2) def dsp_DAM(now_DAM, color_back, color_text): # DAM 数値表示 背景を黄色にし、文字色は紫色 # 0 1 2 3 text_DAM = [' 1.3dB', ' 2.8dB', ' 5.8dB', '11.8dB'] if now_DAM >= 0 and now_DAM <= 3: # LCD.fill_rect(32-2, 350 -20*now_DAM, 16*6 +4, 20, color_back) # LCD.text_scaled(text_DAM[now_DAM], 32, 350+2 -20*now_DAM, color_text, 2) LCD.fill_rect(DAMxs[now_DAM]-2, DAMys[now_DAM], 16*DAMcn +4, 20, color_back) LCD.text_scaled(text_DAM[now_DAM], DAMxs[now_DAM], DAMys[now_DAM]+2, color_text, 2) def dsp_DVB(now_DVB, color_back, color_text): # DVB 数値表示 背景を黄色にし、文字色は紫色 # 0 1 2 3 text_DVB = [' 3.4%', ' 6.7%', ' 13.5%', ' 26.8%'] if now_DVB >= 0 and now_DVB <= 3: # LCD.fill_rect(192-2, 350 -20*now_DVB, 16*6 +4, 20, color_back) # LCD.text_scaled(text_DVB[now_DVB], 192, 350+2 -20*now_DVB, color_text, 2) LCD.fill_rect(DVBxs[now_DVB]-2, DVBys[now_DVB], 16*DVBcn +4, 20, color_back) LCD.text_scaled(text_DVB[now_DVB], DVBxs[now_DVB], DVBys[now_DVB]+2, color_text, 2) def dsp_EAM(now_EAM, color_back, color_text): # EAM 数値表示 背景を黄色にし、文字色は紫色 # 0 1 text_EAM = ['off', 'on '] if now_EAM >= 0 and now_EAM <= 1: # LCD.fill_rect(32-2, 430 -20*now_EAM, 16*6 +4, 20, color_back) # LCD.text_scaled(text_EAM[now_EAM], 32, 430+2 -20*now_EAM, color_text, 2) LCD.fill_rect(EAMxs[now_EAM]-2, EAMys[now_EAM], 16*EAMcn +4, 20, color_back) LCD.text_scaled(text_EAM[now_EAM], EAMxs[now_EAM], EAMys[now_EAM]+2, color_text, 2) def dsp_EVB(now_EVB, color_back, color_text): # EVB 数値表示 背景を黄色にし、文字色は紫色 # 0 1 text_EVB = ['off', 'on '] if now_EVB >= 0 and now_EVB <= 1: # LCD.fill_rect(192-2, 430 -20*now_EVB, 16*6 +4, 20, color_back) # LCD.text_scaled(text_EVB[now_EVB], 192, 430+2 -20*now_EVB, color_text, 2) LCD.fill_rect(EVBxs[now_EVB]-2, EVBys[now_EVB], 16*EVBcn +4, 20, color_back) LCD.text_scaled(text_EVB[now_EVB], EVBxs[now_EVB], EVBys[now_EVB]+2, color_text, 2) def dsp_BO(now_BO, color_back, color_text): # BO 数値表示 背景を黄色にし、文字色は紫色 # 0 1 2 3 # 20251006 Change # text_BO = [' 2 ', ' 1 ', ' 1/2 ', ' 1/4 '] # 20251023 Change text_BO = [' 0 ', ' -1 ', ' -2 ', ' -3 '] if now_BO >= 0 and now_BO <= max_BO: LCD.fill_rect(BOxs[now_BO]-2, BOys[now_BO], 16*BOcn +4, 20, color_back) LCD.text_scaled(text_BO[now_BO], BOxs[now_BO], BOys[now_BO]+2, color_text, 2) def dsp_LFO(now_LFO, color_back, color_text): # LFO 数値表示 背景を黄色にし、文字色は紫色 # 0 1 2 3 text_LFO = ['1.8Hz', '4.0Hz', '5.9Hz', '7.0Hz'] if now_LFO >= 0 and now_LFO <= max_LFO: LCD.fill_rect(LFOxs[now_LFO]-2, LFOys[now_LFO], 16*LFOcn +4, 20, color_back) LCD.text_scaled(text_LFO[now_LFO], LFOxs[now_LFO], LFOys[now_LFO]+2, color_text, 2) def dsp_TN(now_TN, color_back, color_text): LCD.fill_rect(TNxs[now_TN], TNys[now_TN], 16*TNcn , 30, color_back) LCD.text_scaled(f'{now_TN:>2}', TNxs[now_TN]+8, TNys[now_TN]+7, color_text, 2) # Full Keyboard Button 表示 def dsp_FullKeyboard(mode_Shift, color_back, color_text): LCD.fill_rect(FKxb, FKyb, FKcw *key_c , FKch *key_r, color_back) xbt2 = 2 # 文字背景の X 周囲（pixel数） ybt2 = 2 # 文字背景の X 周囲（pixel数） xb = 8 yb = 8 # Key Top 文字表示 for y in range(key_r): for x in range(key_c): if mode_Shift == 0: # Lower LCD.text_scaled(FKv0[y][x], zone_FKs[x][y][0] +xb, zone_FKs[x][y][1] +yb, color_text, 2) else: # Upper LCD.text_scaled(FKv1[y][x], zone_FKs[x][y][0] +xb, zone_FKs[x][y][1] +yb, color_text, 2) # BS : Back Space col = 9 row = 0 LCD.fill_rect(zone_FKs[col][row][0], zone_FKs[col][row][1], FKcw, FKch, LCD.RED) LCD.fill_rect(zone_FKs[col][row][0] +xbt2, zone_FKs[col][row][1] +ybt2, FKcw -xbt2 *2, FKch -ybt2 *2, LCD.WHITE) LCD.text_scaled('<', zone_FKs[col][row][0] +xb, zone_FKs[col][row][1] +yb, LCD.RED, 2) # Enter col = 9 row = 3 # chr_h = 16 LCD.fill_rect(zone_FKs[col][row][0], zone_FKs[col][row][1], FKcw, FKch *2, LCD.RED) LCD.fill_rect(zone_FKs[col][row][0] +xbt2, zone_FKs[col][row][1] +ybt2, FKcw -xbt2 *2, FKch *2 -ybt2 *2, LCD.WHITE) LCD.text_scaled('E', zone_FKs[col][row][0] +xb, zone_FKs[col][row][1] +yb, LCD.RED, 2) LCD.text_scaled('n', zone_FKs[col][row][0] +xb, zone_FKs[col][row][1] +yb +chr_h, LCD.RED, 2) LCD.text_scaled('t', zone_FKs[col][row][0] +xb, zone_FKs[col][row][1] +yb +chr_h *2 +ybt2, LCD.RED, 2) # Shift col = 0 row = 5 LCD.fill_rect(zone_FKs[col][row][0], zone_FKs[col][row][1], FKcw *2, FKch, LCD.RED) LCD.fill_rect(zone_FKs[col][row][0] +xbt2, zone_FKs[col][row][1] +ybt2, FKcw *2 -xbt2 *2, FKch -ybt2 *2, LCD.WHITE) LCD.text_scaled('sft', zone_FKs[col][row][0] +xb, zone_FKs[col][row][1] +yb, LCD.RED, 2) # Space col = 2 row = 5 LCD.fill_rect(zone_FKs[col][row][0], zone_FKs[col][row][1], FKcw *2, FKch, LCD.RED) LCD.fill_rect(zone_FKs[col][row][0] +xbt2, zone_FKs[col][row][1] +ybt2, FKcw *2 -xbt2 *2, FKch -ybt2 *2, LCD.WHITE) LCD.text_scaled('spc', zone_FKs[col][row][0] +xb, zone_FKs[col][row][1] +yb, LCD.RED, 2) # 押されているボタンを 指定された背景色、文字色で表示する def dsp_btn(mode_Shift, btn, col, row, color_back, color_text): xbt2 = 2 # 文字背景の X 周囲（pixel数） ybt2 = 2 # 文字背景の X 周囲（pixel数） xb = 8 yb = 8 # 背景 LCD.fill_rect(zone_FKs[col][row][0], zone_FKs[col][row][1], FKcw , FKch, color_back) # 文字表示 row col が入れ替わることに留意 if mode_Shift == 0: # Lower LCD.text_scaled(FKv0[row][col], zone_FKs[col][row][0] +xb, zone_FKs[col][row][1] +yb, color_text, 2) else: # Upper LCD.text_scaled(FKv1[row][col], zone_FKs[col][row][0] +xb, zone_FKs[col][row][1] +yb, color_text, 2) if btn == 'BS': col = 9 row = 0 LCD.fill_rect(zone_FKs[col][row][0], zone_FKs[col][row][1], FKcw, FKch, LCD.RED) LCD.fill_rect(zone_FKs[col][row][0] +xbt2, zone_FKs[col][row][1] +ybt2, FKcw -xbt2 *2, FKch -ybt2 *2, LCD.YELLOW) LCD.text_scaled('<', zone_FKs[col][row][0] +xb, zone_FKs[col][row][1] +yb, LCD.RED, 2) elif btn == 'Enter': col = 9 row = 3 # chr_h = 16 LCD.fill_rect(zone_FKs[col][row][0], zone_FKs[col][row][1], FKcw, FKch *2, LCD.RED) LCD.fill_rect(zone_FKs[col][row][0] +xbt2, zone_FKs[col][row][1] +ybt2, FKcw -xbt2 *2, FKch *2 -ybt2 *2, LCD.YELLOW) LCD.text_scaled('E', zone_FKs[col][row][0] +xb, zone_FKs[col][row][1] +yb, LCD.RED, 2) LCD.text_scaled('n', zone_FKs[col][row][0] +xb, zone_FKs[col][row][1] +yb +chr_h, LCD.RED, 2) LCD.text_scaled('t', zone_FKs[col][row][0] +xb, zone_FKs[col][row][1] +yb +chr_h *2 +ybt2, LCD.RED, 2) elif btn == 'Shift': col = 0 row = 5 LCD.fill_rect(zone_FKs[col][row][0], zone_FKs[col][row][1], FKcw *2, FKch, LCD.RED) LCD.fill_rect(zone_FKs[col][row][0] +xbt2, zone_FKs[col][row][1] +ybt2, FKcw *2 -xbt2 *2, FKch -ybt2 *2, LCD.YELLOW) LCD.text_scaled('sft', zone_FKs[col][row][0] +xb, zone_FKs[col][row][1] +yb, LCD.RED, 2) elif btn == 'Space': col = 2 row = 5 LCD.fill_rect(zone_FKs[col][row][0], zone_FKs[col][row][1], FKcw *2, FKch, LCD.RED) LCD.fill_rect(zone_FKs[col][row][0] +xbt2, zone_FKs[col][row][1] +ybt2, FKcw *2 -xbt2 *2, FKch -ybt2 *2, LCD.YELLOW) LCD.text_scaled('spc', zone_FKs[col][row][0] +xb, zone_FKs[col][row][1] +yb, LCD.RED, 2) def bold_pixel(x, y, color, scale): if scale >= 2: s = int(scale /2) x = 0 if (x -s) < 0 else x -s y = 0 if (y -s) < 0 else y -s LCD.fill_rect(x, y, scale, scale, color) # 座標ポイント zs ze で指定された２点のPixel および、その周囲の8点同士を線で描く def bold_line(zs, ze, color): for x in range(-1,2): for y in range(-1,2): LCD.line(zs[0] +x, zs[1] +y, ze[0] +x, ze[1] +y, color) # 座標ポイント で指定された２点のPixel および、右側と下側 ４点同士を線で描く def bold_line2(zs, ze, color): for x in range(2): for y in range(2): LCD.line(zs[0] +x, zs[1] +y, ze[0] +x, ze[1] +y, color) # 2025/09/16-20:06 Add # OP1, OP2, OP3, OP4 の開始座標を、TAB = TabCoordinate() に書き込む # 存在しない OP3 や OP4 は [0, 0] として登録 def alg_zs_save(zl1, zl2, zl3, zl4): op_max = 5 # zlOP を保存 zlOP = [None] *op_max zlOP[0] = [0, 0] zlOP[1] = zl1 zlOP[2] = zl2 zlOP[3] = zl3 zlOP[4] = zl4 # 上段に表示する OP1 ~ OP4 の中心線の開始座標である # alg_patarn(alg, stage, color_line, color_back, color_text) の使用を前提 TAB.alg_zlOP_save(zlOP) # タッチ領域用の座標生成 scale = 2 xb = 2 # line X の太さ（pixel数） yb = 2 # line Y の太さ（pixel数） w = 8 *3 *scale +xb*2 # 52 =文字幅 8 pixel 文字 x 3文字 × 2 +4 h = 8 *scale +yb*2 # 20 =文字高さ 8 pixel × 2 +4 if zl1[0] == 0 and zl1[1] == 0: zOP1s = zl1 zOP1e = zl1 else: zOP1s = [zl1[0], zl1[1] -5*scale] zOP1e = [zOP1s[0] +w, zOP1s[1] +h] if zl2[0] == 0 and zl2[1] == 0: zOP2s = zl2 zOP2e = zl2 else: zOP2s = [zl2[0], zl2[1] -5*scale] zOP2e = [zOP2s[0] +w, zOP2s[1] +h] if zl3[0] == 0 and zl3[1] == 0: zOP3s = zl3 zOP3e = zl3 else: zOP3s = [zl3[0], zl3[1] -5*scale] zOP3e = [zOP3s[0] +w, zOP3s[1] +h] if zl4[0] == 0 and zl4[1] == 0: zOP4s = zl4 zOP4e = zl4 else: zOP4s = [zl4[0], zl4[1] -5*scale] zOP4e = [zOP4s[0] +w, zOP4s[1] +h] # タッチ領域用の座標保存 TAB.alg_zOP_save(zOP1s, zOP1e, zOP2s, zOP2e, zOP3s, zOP3e, zOP4s, zOP4e) # ALG op（オペレーション）の四角の枠と数値を表示する def alg_op(op_num_text, zl, fb,color_line, color_back, color_text, scale): xb = 2 # line X の太さ（pixel数） yb = 2 # line Y の太さ（pixel数） xf = 7 # FB line の位置 x差分 yf = 11 # FB line の位置 y差分 xt = 2 # Text の開始位置 x差分 yt = -3 # Text の開始位置 y差分 if scale == 2: zt = [zl[0] +xt*scale, zl[1] +yt*scale] zs = [zl[0] , zl[1] -5*scale] zf = [zl[0] -xf*scale, zl[1] -yf*scale] w_op = 24*scale # 文字幅 8 pixel 文字 x 3文字 h_op = 8*scale # 文字高さ else: zt = [zl[0] +xt, zl[1] +yt] zs = [zl[0] , zl[1] -5] zf = [zl[0] -xf, zl[1] -yf] w_op = 24 # 文字幅 8 pixel 文字 x 3文字 h_op = 8 # 文字高さ if scale == 2: if fb ==1: # フィードバックの枠線を描く、中抜き方式 LCD.fill_rect(zf[0], zf[1], w_op +xb*2 +xf*2*scale, yf*scale +yb ,color_line) LCD.fill_rect(zf[0] +xb, zf[1] +yb, w_op +xf*2*scale, yf*scale -yb ,LCD.WHITE) LCD.fill_rect(zs[0], zs[1], w_op +xb*2, h_op +yb*2, color_line) LCD.fill_rect(zs[0] +xb, zs[1] +yb, w_op, h_op, color_back) # LCD.text(op_num_text, zt[0], zt[1], color_text) LCD.text_scaled(op_num_text, zt[0], zt[1], color_text, scale) else: if fb ==1: # フィードバックの枠線を描く、中抜き方式 LCD.fill_rect(zf[0], zf[1], w_op +xb*2 +xf*2, yf +yb ,color_line) LCD.fill_rect(zf[0] +xb, zf[1] +yb, w_op +xf*2, yf -yb ,LCD.WHITE) LCD.fill_rect(zs[0], zs[1], w_op +xb*2, h_op +yb*2, color_line) LCD.fill_rect(zs[0] +xb, zs[1] +yb, w_op, h_op, color_back) LCD.text(op_num_text, zt[0], zt[1], color_text) # ALG Label を下段の alg表示の左側に表示 def alg_label(alg, color_back, color_text): # text 開始座標の取得 if alg >= 0 and alg <= 7: zALGs = TAB.get_zALGs() zt = zALGs[alg] LCD.fill_rect(zt[0], zt[1], 24, 32, color_back) LCD.text('ALG', zt[0], zt[1], color_text) LCD.text_scaled(f'{alg}', zt[0], zt[1] +10, color_text, 2) # 選択された alg-labelをハイライト表示するとともに、上段にも表示する def alg_label_HL(alg): alg_max = 8 for i in range(alg_max): alg_label(i, LCD.BLUEGREEN, LCD.RED) # ハイライト表示 alg_label(alg, LCD.GREEN, LCD.RED) # 表示領域の指定（mainで定義済みだが） ONLY_DOWN = 0 # 下段のみに表示 ONLY_UP = 1 # 上段のみに表示 BOTH = 2 # 上段と下段の両方に表示 # 上段の表示域をクリア dspFillUpper(LCD.WHITE) alg_on_stage = alg # 拡大して上半分に表示したい alg番号 stage = alg_on_stage *3 + ONLY_UP # 暗号化 alg_patarn(alg, stage, LCD.BLACK, LCD.YELLOW, LCD.RED) # 選択された algを 上段に表示。選択された op_num を High Light表示。 # def alg_op_HL(alg, op_num): を改名 def dsp_ALGup(alg, op_num): # 表示領域の指定（mainで定義済みだが） ONLY_DOWN = 0 # 下段のみに表示 ONLY_UP = 1 # 上段のみに表示 BOTH = 2 # 上段と下段の両方に表示 # 上段の表示域をクリア dspFillUpper(LCD.WHITE) # 指定された alg を上段に表示する alg_on_stage = alg # 拡大して上半分に表示したい alg番号 stage = alg_on_stage *3 + ONLY_UP # 暗号化 alg_patarn(alg, stage, LCD.BLACK, LCD.YELLOW, LCD.RED) # ALG OP の表示用の座標を取得 zlOP = TAB.get_zlOP() # ALG op（オペレーション）の四角の枠と数値を表示する # alg_op(op_num_text, zl, fb, color_line, color_back, color_text, scale) if alg == 0 or alg == 1: for i in range(1, 3): op_num_text = f' {i} ' zl = zlOP[i] fb = 0 # FB Line なし if i == op_num: # High Light 表示 alg_op(op_num_text, zl, fb, LCD.BLACK, LCD.GREEN, LCD.RED, 2) else: # Normal 表示 alg_op(op_num_text, zl, fb, LCD.BLACK, LCD.YELLOW, LCD.RED, 2) else: for i in range(1, 5): op_num_text = f' {i} ' zl = zlOP[i] fb = 0 # FB Line なし if i == op_num: # High Light 表示 alg_op(op_num_text, zl, fb, LCD.BLACK, LCD.GREEN, LCD.RED, 2) else: # Normal 表示 alg_op(op_num_text, zl, fb, LCD.BLACK, LCD.YELLOW, LCD.RED, 2) # 上段に、ToneNumber ToneNmae および 選択された alg を表示 def dsp_ALG_TN(alg, op_num, tone_num, tone_name): # 表示領域の指定（mainで定義済みだが） ONLY_DOWN = 0 # 下段のみに表示 ONLY_UP = 1 # 上段のみに表示 BOTH = 2 # 上段と下段の両方に表示 # 上段の表示域をクリア dspFillUpper(LCD.WHITE) alg_on_stage = alg # 拡大して上半分に表示したい alg番号 stage = alg_on_stage *3 + ONLY_UP # 暗号化 alg_patarn(alg, stage, LCD.BLACK, LCD.YELLOW, LCD.RED) # ALG OP の表示用の座標を取得 zlOP = TAB.get_zlOP() # ALG op（オペレーション）の四角の枠と数値を表示する # alg_op(op_num_text, zl, fb, color_line, color_back, color_text, scale) if alg == 0 or alg == 1: for i in range(1, 3): op_num_text = f' {i} ' zl = zlOP[i] fb = 0 # FB Line なし if i == op_num: # High Light 表示 alg_op(op_num_text, zl, fb, LCD.BLACK, LCD.GREEN, LCD.RED, 2) else: # Normal 表示 alg_op(op_num_text, zl, fb, LCD.BLACK, LCD.YELLOW, LCD.RED, 2) else: for i in range(1, 5): op_num_text = f' {i} ' zl = zlOP[i] fb = 0 # FB Line なし if i == op_num: # High Light 表示 alg_op(op_num_text, zl, fb, LCD.BLACK, LCD.GREEN, LCD.RED, 2) else: # Normal 表示 alg_op(op_num_text, zl, fb, LCD.BLACK, LCD.YELLOW, LCD.RED, 2) # ToneNumber ToneNmae を上段に表示する alg番号部分に上書き text = f'{tone_num:2}:{tone_name}' chr_num = len(text) zs = [10, 35] # dsp_text_bar(text, zs, chr_num, color_back, color_text) dsp_text_bar(text, zs, chr_num, LCD.WHITE, LCD.RED) # ALG を上段と下段の決まった位置に表示する。 # 上段に表示する場合は ２倍に拡大表示する。 # 上段のみ、下段のみ、両方の選択は def alg_patarn(alg, stage, color_line, color_back, color_text): # scale == 2 の場合は、２倍に拡大して上段に表示する。その位置の設定 zl_algS = [10, 40] # 拡大して表示する場合の開始位置 # 下半分の決まった位置に表示する各アルゴリズム基準となる OP左端の上下中心点の設定 zl_alg0 = [173 +28, 245 +12+16 +5] zl_alg1 = [ 31 +28, 245 +12+16 +5] zl_alg2 = [ 31 +28, 245 +12+16*3 +22 +3] zl_alg3 = [173, 245 +12+16*3 +3] zl_alg4 = [173, 245 +12+16*5 +22] zl_alg5 = [173 +28, 245 +12+16*7 +22] zl_alg6 = [173, 245 +12+16*9 +22*2] zl_alg7 = [ 31, 245 +12+16*5 +22*4] alg_max = 8 alg_LBs = [None] *alg_max alg_LBe = [None] *alg_max # ALG タイトル表示開始座標 alg_textS = [10, 35] # 拡大して表示する場合の開始位置 alg_LBs[0] = [165 -27, 245 +12 +10] alg_LBs[1] = [ 5, 245 +12 +10] alg_LBs[2] = [ 5, 245 +12+16*2 +22 +30] alg_LBs[3] = [165 -27, 245 +12+16*2 +10 +3] alg_LBs[4] = [165 -27, 245 +12+16*4 +22] alg_LBs[5] = [165 -27, 245 +12+16*6 +22 +10] alg_LBs[6] = [165 -27, 245 +12+16*8 +22*2 +10] alg_LBs[7] = [ 5, 245 +12+16*4 +22*4 +20] # ALG タイトル表示終末座標 text_w = 8 *3 text_h = 32 for i in range(alg_max): alg_LBe[i] = [alg_LBs[i][0] +text_w, alg_LBs[i][1] +text_h] # ALG タイトル表示座標の保存 TAB.alg_zALG_save(alg_LBs, alg_LBe) # 暗号化された stage を復号 alg_on_stage = int(stage /3) only_down = False only_up = False both = False if stage %3 == 0: only_down = True # 下半分のみ表示 elif stage %3 == 1: only_up = True # 上半分のみ表示 else: # stage %3 == 2 both = True # 両方表示 if alg == 0: if alg == alg_on_stage and (only_up or both): # 上半分に描く 描画ポイントの設定 z_op1 = zl_algS z_op2 = [z_op1[0] +28 +14 , z_op1[1]] z_je = [z_op2[0] +28 +14 , z_op2[1]] # 描画ポイントを拡張する z_op1 = [z_op1[0]*2, z_op1[1]*2] z_op2 = [z_op2[0]*2, z_op2[1]*2] z_je = [z_je[0]*2, z_je[1]*2] # 横線を描く bold_line2(z_op1, z_je, color_line) # op 表示 alg_op(' 1 ', z_op1, 1, color_line, color_back, color_text, 2) alg_op(' 2 ', z_op2, 0, color_line, color_back, color_text, 2) # op1 ~ op4 座標登録 z_op3 = [0, 0] z_op4 = [0, 0] alg_zs_save(z_op1, z_op2, z_op3, z_op4) # ALG 表示（共通） zt = alg_textS LCD.text_scaled(f'ALG: {alg}', zt[0], zt[1], color_text, 2) if alg != alg_on_stage or (alg == alg_on_stage and (only_down or both)): # 下半分に描く 描画ポイントの設定 z_op1 = zl_alg0 z_op2 = [z_op1[0] +28 +14 , z_op1[1]] z_je = [z_op2[0] +28 +14 , z_op2[1]] # 横線を描く bold_line2(z_op1, z_je, color_line) # op 表示 alg_op(' 1 ', z_op1, 1, color_line, color_back, color_text, 1) alg_op(' 2 ', z_op2, 0, color_line, color_back, color_text, 1) # ALG 表示 alg_label(alg, LCD.BLUEGREEN, color_text) elif alg == 1: if alg == alg_on_stage and (only_up or both): # 上半分に描く 描画ポイントの設定 z_op1 = zl_algS z_op2 = [z_op1[0], z_op1[1] +22] z_je = [z_op1[0] +28 +14*2, z_op1[1]] z_j1 = [z_op1[0] +28 +14 , z_op1[1]] z_j2 = [z_op2[0] +28 +14 , z_op2[1]] # 描画ポイントを拡張する z_op1 = [z_op1[0]*2, z_op1[1]*2] z_op2 = [z_op2[0]*2, z_op2[1]*2] z_je = [z_je[0]*2, z_je[1]*2] z_j1 = [z_j1[0]*2, z_j1[1]*2] z_j2 = [z_j2[0]*2, z_j2[1]*2] # 横線を描く bold_line2(z_op1, z_je, color_line) bold_line2(z_op2, z_j2, color_line) bold_line2(z_j1 , z_j2, color_line) # op 表示 alg_op(' 1 ', z_op1, 1, color_line, color_back, color_text, 2) alg_op(' 2 ', z_op2, 0, color_line, color_back, color_text, 2) # op1 ~ op4 座標登録 z_op3 = [0, 0] z_op4 = [0, 0] alg_zs_save(z_op1, z_op2, z_op3, z_op4) # ALG 表示（共通） zt = alg_textS LCD.text_scaled(f'ALG: {alg}', zt[0], zt[1], color_text, 2) if alg != alg_on_stage or (alg == alg_on_stage and (only_down or both)): # 下半分に描く 描画ポイントの設定 z_op1 = zl_alg1 z_op2 = [z_op1[0], z_op1[1] +22] z_je = [z_op1[0] +28 +14*2, z_op1[1]] z_j1 = [z_op1[0] +28 +14 , z_op1[1]] z_j2 = [z_op2[0] +28 +14 , z_op2[1]] # 横線を描く bold_line2(z_op1, z_je, color_line) bold_line2(z_op2, z_j2, color_line) bold_line2(z_j1 , z_j2, color_line) # op 表示 alg_op(' 1 ', z_op1, 1, color_line, color_back, color_text, 1) alg_op(' 2 ', z_op2, 0, color_line, color_back, color_text, 1) # ALG 表示 alg_label(alg, LCD.BLUEGREEN, color_text) elif alg == 2: if alg == alg_on_stage and (only_up or both): # 上半分に描く 描画ポイントの設定 z_op1 = zl_algS z_op2 = [z_op1[0], z_op1[1] +22] z_op3 = [z_op1[0], z_op1[1] +22*2] z_op4 = [z_op1[0], z_op1[1] +22*3] z_je = [z_op1[0] +28 +14*2, z_op1[1]] z_j1 = [z_op1[0] +28 +14 , z_op1[1]] z_j2 = [z_op2[0] +28 +14 , z_op2[1]] z_j3 = [z_op3[0] +28 +14 , z_op3[1]] z_j4 = [z_op4[0] +28 +14 , z_op4[1]] # 描画ポイントを拡張する z_op1 = [z_op1[0]*2, z_op1[1]*2] z_op2 = [z_op2[0]*2, z_op2[1]*2] z_op3 = [z_op3[0]*2, z_op3[1]*2] z_op4 = [z_op4[0]*2, z_op4[1]*2] z_je = [z_je[0]*2, z_je[1]*2] z_j1 = [z_j1[0]*2, z_j1[1]*2] z_j2 = [z_j2[0]*2, z_j2[1]*2] z_j3 = [z_j3[0]*2, z_j3[1]*2] z_j4 = [z_j4[0]*2, z_j4[1]*2] # 横線を描く bold_line2(z_op1, z_je, color_line) bold_line2(z_op2, z_j2, color_line) bold_line2(z_op3, z_j3, color_line) bold_line2(z_op4, z_j4, color_line) bold_line2(z_j1 , z_j4, color_line) # op 表示 alg_op(' 1 ', z_op1, 1, color_line, color_back, color_text, 2) alg_op(' 2 ', z_op2, 0, color_line, color_back, color_text, 2) alg_op(' 3 ', z_op3, 1, color_line, color_back, color_text, 2) alg_op(' 4 ', z_op4, 0, color_line, color_back, color_text, 2) # op1 ~ op4 座標登録 alg_zs_save(z_op1, z_op2, z_op3, z_op4) # ALG 表示（共通） zt = alg_textS LCD.text_scaled(f'ALG: {alg}', zt[0], zt[1], color_text, 2) if alg != alg_on_stage or (alg == alg_on_stage and (only_down or both)): # 下半分に描く 描画ポイントの設定 z_op1 = zl_alg2 z_op2 = [z_op1[0], z_op1[1] +22] z_op3 = [z_op1[0], z_op1[1] +22*2] z_op4 = [z_op1[0], z_op1[1] +22*3] z_je = [z_op1[0] +28 +14*2, z_op1[1]] z_j1 = [z_op1[0] +28 +14 , z_op1[1]] z_j2 = [z_op2[0] +28 +14 , z_op2[1]] z_j3 = [z_op3[0] +28 +14 , z_op3[1]] z_j4 = [z_op4[0] +28 +14 , z_op4[1]] # 横線を描く bold_line2(z_op1, z_je, color_line) bold_line2(z_op2, z_j2, color_line) bold_line2(z_op3, z_j3, color_line) bold_line2(z_op4, z_j4, color_line) bold_line2(z_j1 , z_j4, color_line) # op 表示 alg_op(' 1 ', z_op1, 1, color_line, color_back, color_text, 1) alg_op(' 2 ', z_op2, 0, color_line, color_back, color_text, 1) alg_op(' 3 ', z_op3, 1, color_line, color_back, color_text, 1) alg_op(' 4 ', z_op4, 0, color_line, color_back, color_text, 1) # ALG 表示 alg_label(alg, LCD.BLUEGREEN, color_text) elif alg == 3: if alg == alg_on_stage and (only_up or both): # 上半分に描く 描画ポイントの設定 z_op1 = zl_algS z_op2 = [z_op1[0] , z_op1[1] +22] z_op3 = [z_op1[0] +28 +14 , z_op1[1] +22] z_op4 = [z_op1[0] +28*2 +14*3 , z_op1[1]] z_je = [z_op4[0] +28 +14 , z_op4[1]] z_j1 = [z_op1[0] +28*2 +14*2 , z_op1[1]] z_j3 = [z_op3[0] +28 +14 , z_op3[1]] # 描画ポイントを拡張する z_op1 = [z_op1[0]*2, z_op1[1]*2] z_op2 = [z_op2[0]*2, z_op2[1]*2] z_op3 = [z_op3[0]*2, z_op3[1]*2] z_op4 = [z_op4[0]*2, z_op4[1]*2] z_je = [z_je[0]*2, z_je[1]*2] z_j1 = [z_j1[0]*2, z_j1[1]*2] z_j3 = [z_j3[0]*2, z_j3[1]*2] # 横線を描く bold_line2(z_op1, z_je, color_line) bold_line2(z_op2, z_j3, color_line) bold_line2(z_j1, z_j3, color_line) # op 表示 alg_op(' 1 ', z_op1, 1, color_line, color_back, color_text, 2) alg_op(' 2 ', z_op2, 0, color_line, color_back, color_text, 2) alg_op(' 3 ', z_op3, 0, color_line, color_back, color_text, 2) alg_op(' 4 ', z_op4, 0, color_line, color_back, color_text, 2) # op1 ~ op4 座標登録 alg_zs_save(z_op1, z_op2, z_op3, z_op4) # ALG 表示（共通） zt = alg_textS LCD.text_scaled(f'ALG: {alg}', zt[0], zt[1], color_text, 2) if alg != alg_on_stage or (alg == alg_on_stage and (only_down or both)): # 下半分に描く 描画ポイントの設定 z_op1 = zl_alg3 z_op2 = [z_op1[0] , z_op1[1] +22] z_op3 = [z_op1[0] +28 +14 , z_op1[1] +22] z_op4 = [z_op1[0] +28*2 +14*3 , z_op1[1]] z_je = [z_op4[0] +28 +14 , z_op4[1]] z_j1 = [z_op1[0] +28*2 +14*2 , z_op1[1]] z_j3 = [z_op3[0] +28 +14 , z_op3[1]] # 横線を描く bold_line2(z_op1, z_je, color_line) bold_line2(z_op2, z_j3, color_line) bold_line2(z_j1, z_j3, color_line) # op 表示 alg_op(' 1 ', z_op1, 1, color_line, color_back, color_text, 1) alg_op(' 2 ', z_op2, 0, color_line, color_back, color_text, 1) alg_op(' 3 ', z_op3, 0, color_line, color_back, color_text, 1) alg_op(' 4 ', z_op4, 0, color_line, color_back, color_text, 1) # ALG 表示 alg_label(alg, LCD.BLUEGREEN, color_text) elif alg == 4: if alg == alg_on_stage and (only_up or both): # 上半分に描く 描画ポイントの設定 z_op1 = zl_algS z_op2 = [z_op1[0] +28 +14 , z_op1[1]] z_op3 = [z_op2[0] +28 +7 , z_op1[1]] z_op4 = [z_op3[0] +28 +7 , z_op1[1]] z_je = [z_op4[0] +28 +14 , z_op2[1]] # 描画ポイントを拡張する z_op1 = [z_op1[0]*2, z_op1[1]*2] z_op2 = [z_op2[0]*2, z_op2[1]*2] z_op3 = [z_op3[0]*2, z_op3[1]*2] z_op4 = [z_op4[0]*2, z_op4[1]*2] z_je = [z_je[0]*2, z_je[1]*2] # 横線を描く bold_line2(z_op1, z_je, color_line) # op 表示 # op 表示 alg_op(' 1 ', z_op1, 1, color_line, color_back, color_text, 2) alg_op(' 2 ', z_op2, 0, color_line, color_back, color_text, 2) alg_op(' 3 ', z_op3, 0, color_line, color_back, color_text, 2) alg_op(' 4 ', z_op4, 0, color_line, color_back, color_text, 2) # op1 ~ op4 座標登録 alg_zs_save(z_op1, z_op2, z_op3, z_op4) # ALG 表示（共通） zt = alg_textS LCD.text_scaled(f'ALG: {alg}', zt[0], zt[1], color_text, 2) if alg != alg_on_stage or (alg == alg_on_stage and (only_down or both)): # 下半分に描く 描画ポイントの設定 z_op1 = zl_alg4 z_op2 = [z_op1[0] +28 +14 , z_op1[1]] z_op3 = [z_op2[0] +28 +7 , z_op1[1]] z_op4 = [z_op3[0] +28 +7 , z_op1[1]] z_je = [z_op4[0] +28 +14 , z_op2[1]] # 横線を描く bold_line2(z_op1, z_je, color_line) # op 表示 alg_op(' 1 ', z_op1, 1, color_line, color_back, color_text, 1) alg_op(' 2 ', z_op2, 0, color_line, color_back, color_text, 1) alg_op(' 3 ', z_op3, 0, color_line, color_back, color_text, 1) alg_op(' 4 ', z_op4, 0, color_line, color_back, color_text, 1) # ALG 表示 alg_label(alg, LCD.BLUEGREEN, color_text) elif alg == 5: if alg == alg_on_stage and (only_up or both): # 上半分に描く 描画ポイントの設定 z_op1 = zl_algS z_op2 = [z_op1[0] +28 +14 , z_op1[1]] z_op3 = [z_op1[0] , z_op1[1] +22] z_op4 = [z_op2[0] , z_op2[1] +22] z_je = [z_op2[0] +28 +14*2 , z_op2[1]] z_j2 = [z_op2[0] +28 +14 , z_op2[1]] z_j4 = [z_op4[0] +28 +14 , z_op4[1]] # 描画ポイントを拡張する z_op1 = [z_op1[0]*2, z_op1[1]*2] z_op2 = [z_op2[0]*2, z_op2[1]*2] z_op3 = [z_op3[0]*2, z_op3[1]*2] z_op4 = [z_op4[0]*2, z_op4[1]*2] z_je = [z_je[0]*2, z_je[1]*2] z_j2 = [z_j2[0]*2, z_j2[1]*2] z_j4 = [z_j4[0]*2, z_j4[1]*2] # 横線を描く bold_line2(z_op1, z_je, color_line) bold_line2(z_op3, z_j4, color_line) bold_line2(z_j2, z_j4, color_line) # op 表示 alg_op(' 1 ', z_op1, 1, color_line, color_back, color_text, 2) alg_op(' 2 ', z_op2, 0, color_line, color_back, color_text, 2) alg_op(' 3 ', z_op3, 1, color_line, color_back, color_text, 2) alg_op(' 4 ', z_op4, 0, color_line, color_back, color_text, 2) # op1 ~ op4 座標登録 alg_zs_save(z_op1, z_op2, z_op3, z_op4) # ALG 表示（共通） zt = alg_textS LCD.text_scaled(f'ALG: {alg}', zt[0], zt[1], color_text, 2) if alg != alg_on_stage or (alg == alg_on_stage and (only_down or both)): # 下半分に描く 描画ポイントの設定 z_op1 = zl_alg5 z_op2 = [z_op1[0] +28 +14 , z_op1[1]] z_op3 = [z_op1[0] , z_op1[1] +22] z_op4 = [z_op2[0] , z_op2[1] +22] z_je = [z_op2[0] +28 +14*2 , z_op2[1]] z_j2 = [z_op2[0] +28 +14 , z_op2[1]] z_j4 = [z_op4[0] +28 +14 , z_op4[1]] # 横線を描く bold_line2(z_op1, z_je, color_line) bold_line2(z_op3, z_j4, color_line) bold_line2(z_j2, z_j4, color_line) # op 表示 alg_op(' 1 ', z_op1, 1, color_line, color_back, color_text, 1) alg_op(' 2 ', z_op2, 0, color_line, color_back, color_text, 1) alg_op(' 3 ', z_op3, 1, color_line, color_back, color_text, 1) alg_op(' 4 ', z_op4, 0, color_line, color_back, color_text, 1) # ALG 表示 alg_label(alg, LCD.BLUEGREEN, color_text) elif alg == 6: if alg == alg_on_stage and (only_up or both): # 上半分に描く 描画ポイントの設定 z_op1 = zl_algS z_op2 = [z_op1[0] , z_op1[1] +22] z_op3 = [z_op2[0] +28 +14 , z_op2[1]] z_op4 = [z_op3[0] +28 +7 , z_op3[1]] z_je = [z_op1[0] +28*2 +7 +14*5 , z_op1[1]] z_j1 = [z_op1[0] +28*2 +7 +14*4 , z_op1[1]] z_j4 = [z_op4[0] +28 +14 , z_op4[1]] # 描画ポイントを拡張する z_op1 = [z_op1[0]*2, z_op1[1]*2] z_op2 = [z_op2[0]*2, z_op2[1]*2] z_op3 = [z_op3[0]*2, z_op3[1]*2] z_op4 = [z_op4[0]*2, z_op4[1]*2] z_je = [z_je[0]*2, z_je[1]*2] z_j1 = [z_j1[0]*2, z_j1[1]*2] z_j4 = [z_j4[0]*2, z_j4[1]*2] # 横線を描く bold_line2(z_op1, z_je, color_line) bold_line2(z_op2, z_j4, color_line) bold_line2(z_j1, z_j4, color_line) # op 表示 alg_op(' 1 ', z_op1, 1, color_line, color_back, color_text, 2) alg_op(' 2 ', z_op2, 0, color_line, color_back, color_text, 2) alg_op(' 3 ', z_op3, 0, color_line, color_back, color_text, 2) alg_op(' 4 ', z_op4, 0, color_line, color_back, color_text, 2) # op1 ~ op4 座標登録 alg_zs_save(z_op1, z_op2, z_op3, z_op4) # ALG 表示（共通） zt = alg_textS LCD.text_scaled(f'ALG: {alg}', zt[0], zt[1], color_text, 2) if alg != alg_on_stage or (alg == alg_on_stage and (only_down or both)): # 下半分に描く 描画ポイントの設定 z_op1 = zl_alg6 z_op2 = [z_op1[0] , z_op1[1] +22] z_op3 = [z_op2[0] +28 +14 , z_op2[1]] z_op4 = [z_op3[0] +28 +7 , z_op3[1]] z_je = [z_op1[0] +28*2 +7 +14*5 , z_op1[1]] z_j1 = [z_op1[0] +28*2 +7 +14*4 , z_op1[1]] z_j4 = [z_op4[0] +28 +14 , z_op4[1]] # 横線を描く bold_line2(z_op1, z_je, color_line) bold_line2(z_op2, z_j4, color_line) bold_line2(z_j1, z_j4, color_line) # op 表示 alg_op(' 1 ', z_op1, 1, color_line, color_back, color_text, 1) alg_op(' 2 ', z_op2, 0, color_line, color_back, color_text, 1) alg_op(' 3 ', z_op3, 0, color_line, color_back, color_text, 1) alg_op(' 4 ', z_op4, 0, color_line, color_back, color_text, 1) # ALG 表示 alg_label(alg, LCD.BLUEGREEN, color_text) elif alg == 7: if alg == alg_on_stage and (only_up or both): # 上半分に描く 描画ポイントの設定 z_op2 = [zl_algS[0], zl_algS[1] +22] # op2 を起点にする z_op1 = [z_op2[0] +35, z_op2[1] -22] z_op3 = [z_op2[0] +28 +14, z_op2[1]] z_op4 = [z_op1[0] , z_op1[1] +22*2] z_je = [z_op1[0] +28 +21 +14, z_op1[1]] z_j1 = [z_op1[0] +28 +21 , z_op1[1]] z_j3 = [z_op3[0] +28 +14 , z_op3[1]] z_j4 = [z_op4[0] +28 +21 , z_op4[1]] # 描画ポイントを拡張する z_op1 = [z_op1[0]*2, z_op1[1]*2] z_op2 = [z_op2[0]*2, z_op2[1]*2] z_op3 = [z_op3[0]*2, z_op3[1]*2] z_op4 = [z_op4[0]*2, z_op4[1]*2] z_je = [z_je[0]*2, z_je[1]*2] z_j1 = [z_j1[0]*2, z_j1[1]*2] z_j3 = [z_j3[0]*2, z_j3[1]*2] z_j4 = [z_j4[0]*2, z_j4[1]*2] # 横線を描く bold_line2(z_op1, z_je, color_line) bold_line2(z_op2, z_j3, color_line) bold_line2(z_op4, z_j4, color_line) bold_line2(z_j1 , z_j4, color_line) # op 表示 alg_op(' 1 ', z_op1, 1, color_line, color_back, color_text, 2) alg_op(' 2 ', z_op2, 0, color_line, color_back, color_text, 2) alg_op(' 3 ', z_op3, 0, color_line, color_back, color_text, 2) alg_op(' 4 ', z_op4, 0, color_line, color_back, color_text, 2) # op1 ~ op4 座標登録 alg_zs_save(z_op1, z_op2, z_op3, z_op4) # ALG 表示（共通） zt = alg_textS LCD.text_scaled(f'ALG: {alg}', zt[0], zt[1], color_text, 2) if alg != alg_on_stage or (alg == alg_on_stage and (only_down or both)): # 下半分に描く 描画ポイントの設定 z_op2 = [zl_alg7[0], zl_alg7[1] +22] # op2 を起点にする z_op1 = [z_op2[0] +35, z_op2[1] -22] z_op3 = [z_op2[0] +28 +14, z_op2[1]] z_op4 = [z_op1[0] , z_op1[1] +22*2] z_je = [z_op1[0] +28 +21 +14, z_op1[1]] z_j1 = [z_op1[0] +28 +21 , z_op1[1]] z_j3 = [z_op3[0] +28 +14 , z_op3[1]] z_j4 = [z_op4[0] +28 +21 , z_op4[1]] # 横線を描く bold_line2(z_op1, z_je, color_line) bold_line2(z_op2, z_j3, color_line) bold_line2(z_op4, z_j4, color_line) bold_line2(z_j1 , z_j4, color_line) # op 表示 alg_op(' 1 ', z_op1, 1, color_line, color_back, color_text, 1) alg_op(' 2 ', z_op2, 0, color_line, color_back, color_text, 1) alg_op(' 3 ', z_op3, 0, color_line, color_back, color_text, 1) alg_op(' 4 ', z_op4, 0, color_line, color_back, color_text, 1) # ALG 表示 alg_label(alg, LCD.BLUEGREEN, color_text) def select_ALG(tabM_num, tabS_num, ALG_num, tone_num, tone_name): # Main Tab の座標リストを取得 zoneMtab_s = TAB.get_zoneMtab_s() zoneMtab_e = TAB.get_zoneMtab_e() # Sub Tab の座標リストを取得 zoneStab_s = TAB.get_zoneStab_s() zoneStab_e = TAB.get_zoneStab_e() # 上段表示エリアの開始座標と終末座標を取得 zUPs = TAB.get_zUPs() zUPe = TAB.get_zUPe() # 下段表示エリアの開始座標と終末座標を取得 zLWs = TAB.get_zLWs() zLWe = TAB.get_zLWe() ALG_max = 8 # 表示領域の指定（mainで定義済みだが） ONLY_DOWN = 0 # 下段のみに表示 ONLY_UP = 1 # 上段のみに表示 BOTH = 2 # 上段と下段の両方に表示 dspFillLower(LCD.WHITE) # ALG 全パターンの表示 ★★★ zALGs zALGe がセットされる for i in range(ALG_max): dspFillUpper(LCD.WHITE) alg = i alg_on_stage = alg # 拡大して上半分に表示したい alg番号 stage = alg_on_stage *3 + ONLY_DOWN # 暗号化 ONLY_DOWN alg_patarn(alg, stage, LCD.BLACK, LCD.YELLOW, LCD.RED) dspShow() # 選択された ALG のラベル番号の背景色変更と上段への表示 alg_label_HL(ALG_num) LCD.show() # ALG0 ~ ALG7 のラベルの座標リストを取得 ★★★ alg_patarn() を事前に実行しておくこと zALGs = TAB.get_zALGs() zALGe = TAB.get_zALGe() # cnt_zone{n] の初期化 cnt_zone = [None] * ALG_max for i in range(ALG_max): cnt_zone[i] = 0 # cnt_tabM cnt_tabS の初期化 cnt_tabM = [None] * 5 cnt_tabS = [None] * 5 for i in range(5): cnt_tabM[i] = 0 cnt_tabS[i] = 0 # 終了条件の設定 tabM_num_old = tabM_num tabS_num_old = tabS_num # tabM_num または tabS_num が直前の状態と違うものが選択されたら終了 while tabM_num_old == tabM_num and tabS_num_old == tabS_num: get = LCD.touch_get() if get != None: # タッチされているなら X_Point = get[0] Y_Point = get[1] # タッチは下段表示エリアか？ if in_zone(zLWs, zLWe, X_Point, Y_Point): for i in range(ALG_max): if in_zone(zALGs[i], zALGe[i], X_Point, Y_Point): # zALG[i] の周辺ならば print(f'select zALG[{i}]') cnt_zone[i] += 1 if cnt_zone[i] >= TOUCH_TH: ALG_num = i print(f'ALG Select = {ALG_num}') # 選択された ALG のラベル番号の背景色変更と上段への表示 alg_label_HL(ALG_num) LCD.show() # mainTab のタッチで終了 if in_zone(zoneMtab_s[1], zoneMtab_e[4], X_Point, Y_Point): for i in range(1, 5): if in_zone(zoneMtab_s[i], zoneMtab_e[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば print(f'select zoneMtab[{i}]') cnt_tabM[i] += 1 if cnt_tabM[i] >= TOUCH_TH: tabM_num = i print(f'main-menu Select = {tabM_num}') # subTab のタッチで終了 if in_zone(zoneStab_s[1], zoneStab_e[4], X_Point, Y_Point): for i in range(1, 5): if in_zone(zoneStab_s[i], zoneStab_e[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば print(f'select zoneStab[{i}]') cnt_tabS[i] += 1 if cnt_tabS[i] >= TOUCH_TH: tabS_num = i print(f'sub-menu Select = {tabS_num}') else: # ToneNumber ToneNmae を上段の末尾に表示する alg番号部分に上書き text = f'{tone_num:2}:{tone_name}' chr_num = len(text) zs = [10, 220] # dsp_text_bar(text, zs, chr_num, color_back, color_text) dsp_text_bar(text, zs, chr_num, LCD.WHITE, LCD.RED) # cnt_zone{n] の初期化 for i in range(ALG_max): cnt_zone[i] = 0 # cnt_tabM cnt_tabS の初期化 for i in range(5): cnt_tabM[i] = 0 cnt_tabS[i] = 0 LCD.show() return (tabM_num, tabS_num, ALG_num) def one_write_line(zl, color_wave): # zl[[zs], [z1], [z2], [z3], [z4], ] if len(zl) >= 2: z_end = zl[0] for i in range(1, len(zl)): z_start = z_end # y軸は、反転することに注意 z_end =[zl[0][0] +zl[i][0], zl[0][1] -zl[i][1]] bold_line(z_start, z_end, color_wave) # WS 波形をLCD下半分の決まった位置に表示する def wave_form(ws, color_back, color_wave, z=None): WS_max = 31 xs = 0 xb = 8 # 枠の幅 x ys = 264 # 240~259:[WS]Tab 260~263:Line yl = ys +18 # 240~259:[WS]Tab 260~263:Line 中央の線 yb = 3 # 枠の幅 y w = 64 # セルの全体幅 wx = 48 # セルの波形幅 h = 36 # セルの全体高さ hy = 15 # セルの波形高さの半分 sin価数を利用するため 1/2 にしている # ws 番号から描画開始位置を決めるためのテーブル # ws=0, 1, 2, 3, 4, zone_xs = [xs +w*0, xs +w*1, xs +w*2, xs +w*0, xs +w*3, \ # ws=5, 6, 7, 8, 9, xs +w*4, xs +w*0, xs +w*4, xs +w*0, xs +w*1, \ # ws=10, 11, 12, 13, 14, xs +w*2, xs +w*1, xs +w*3, xs +w*4, xs +w*1, \ # ws=15, 16, 17, 18, 19, xs +w*4, xs +w*0, xs +w*1, xs +w*2, xs +w*2, \ # ws=20, 21, 22, 23, 24, xs +w*3, xs +w*4, xs +w*2, xs +w*4, xs +w*0, \ # ws=25, 26, 27, 28, 29, 30, xs +w*1, xs +w*2, xs +w*3, xs +w*3, xs +w*4, xs +w*3] # ws=0, 1, 2, 3, 4, zone_ys = [ys +h*0, ys +h*0, ys +h*0, ys +h*5, ys +h*0, \ # ws=5, 6, 7, 8, 9, ys +h*0, ys +h*4, ys +h*4, ys +h*1, ys +h*1, \ # ws=10, 11, 12, 13, 14, ys +h*1, ys +h*5, ys +h*1, ys +h*1, ys +h*4, \ # ws=15, 16, 17, 18, 19, ys +h*5, ys +h*2, ys +h*2, ys +h*2, ys +h*5, \ # ws=20, 21, 22, 23, 24, ys +h*2, ys +h*2, ys +h*4, ys +h*5, ys +h*3, \ # ws=25, 26, 27, 28, 29, 30, ys +h*3, ys +h*3, ys +h*5, ys +h*3, ys +h*3, ys +h*4] # 波形の Y軸 0 line 上下中心線 zone_yl = [yl +h*0, yl +h*0, yl +h*0, yl +h*5, yl +h*0, \ yl +h*0, yl +h*4, yl +h*4, yl +h*1, yl +h*1, \ yl +h*1, yl +h*5, yl +h*1, yl +h*1, yl +h*4, \ yl +h*0, yl +h*2, yl +h*2, yl +h*2, yl +h*5, \ yl +h*2, yl +h*2, yl +h*4, yl +h*0, yl +h*3, \ yl +h*3, yl +h*3, yl +h*5, yl +h*3, yl +h*3, yl +h*4] # タッチ領域の開始座標 と 終末座標 zWSs = [None] * WS_max zWSe = [None] * WS_max for i in range(WS_max): zWSs[i] = [zone_xs[i], zone_ys[i]] zWSe[i] = [zone_xs[i] + w, zone_ys[i] + h] # 2025/09/16-20:06 Add # WS:0 ~ WS:31 の開始座標と終末座標を、TAB = TabCoordinate() に書き込む TAB.zWS_save(zWSs, zWSe) # 表示位置 z を指定すれば、その場所に表示できる。 if z != None: zone_xs[ws] = z[0] # 250 zone_ys[ws] = z[1] # 180 zone_yl[ws] = zone_ys[ws] +18 # color_back = LCD.GREEN # color_wave = LCD.PURPLE if ws == 0: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) for i in range(wx): xp = zone_xs[ws] +i +xb # 円周360度を 60分割してサイン波形をプロットする yp = zone_yl[ws] -int(math.sin(math.radians(i *(360/wx))) *hy) bold_pixel(xp, yp, color_wave, 3) elif ws == 1: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) for i in range(int(wx/2)+1): xp = zone_xs[ws] +i +xb # 円周360度を 60分割してサイン波形をプロットする yp = zone_yl[ws] -int(math.sin(math.radians(i *(360/wx))) *hy) bold_pixel(xp, yp, color_wave, 3) # 直線部分を描く xp = zone_xs[ws] +xb +24 yp = zone_yl[ws] # 起点 1 2 3 4 5 6 7 8 zl = [[xp,yp], [+24,0]] one_write_line(zl, color_wave) elif ws == 2: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) for i in range(wx): xp = zone_xs[ws] +i +xb # 円周360度を 60分割してサイン波形をプロットする yp = zone_yl[ws] -int(abs(math.sin(math.radians(i *(360/wx))) *hy)) bold_pixel(xp, yp, color_wave, 3) elif ws == 3: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) # 円周360度を 60分割してサイン波形の 1/4 をプロットする for i in range(0, 12): xp = zone_xs[ws] +i +xb yp = zone_yl[ws] -int(abs(math.sin(math.radians(i *(360/wx))) *hy)) bold_pixel(xp, yp, color_wave, 3) # 円周360度を 60分割してサイン波形の 3/4 をプロットする for i in range(24, 36): xp = zone_xs[ws] +i +xb yp = zone_yl[ws] -int(abs(math.sin(math.radians(i *(360/wx))) *hy)) bold_pixel(xp, yp, color_wave, 3) # 直線部分を描く z1 = [zone_xs[ws] +xb +12, zone_ys[ws] +yb +0] z2 = [zone_xs[ws] +xb +12, zone_ys[ws] +yb +hy] z3 = [zone_xs[ws] +xb +24, zone_ys[ws] +yb +hy] bold_line(z1, z2, color_wave) bold_line(z2, z3, color_wave) z4 = [zone_xs[ws] +xb +36, zone_ys[ws] +yb +0] z5 = [zone_xs[ws] +xb +36, zone_ys[ws] +yb +hy] z6 = [zone_xs[ws] +xb +48, zone_ys[ws] +yb +hy] bold_line(z4, z5, color_wave) bold_line(z5, z6, color_wave) elif ws == 4: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) # 円周360度を 60分割してサイン波形をプロットする for i in range(30+1): xp = zone_xs[ws] +i +xb *2 yp = zone_yl[ws] -int(math.sin(math.radians(i *(360/30))) *hy) bold_pixel(xp, yp, color_wave, 3) elif ws == 5: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) # 円周360度を 60分割してサイン波形をプロットする for i in range(30+1): xp = zone_xs[ws] +i +xb *2 yp = zone_yl[ws] -int(abs(math.sin(math.radians(i *(360/30))) *hy)) bold_pixel(xp, yp, color_wave, 3) elif ws == 6: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) # 直線部分を描く xp = zone_xs[ws] +xb yp = zone_yl[ws] zl = [[xp,yp], [0,+hy], [24,+hy], [24,-hy], [48,-hy], [48,0]] one_write_line(zl, color_wave) elif ws == 7: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) # サイン波形の 180~270 をプロットする for i in range(0, 24): xp = zone_xs[ws] +i +xb yp = zone_ys[ws] +yb +int(hy*2 - (abs(math.sin(math.radians(i *(360/(wx*2)) +180))) *(-1) *hy +hy*2)) bold_pixel(xp, yp, color_wave, 3) # サイン波形の 270~360 をプロットする for i in range(24, 48): xp = zone_xs[ws] +i +xb yp = zone_ys[ws] +yb +int(hy*2 - (abs(math.sin(math.radians(i *(360/(wx*2)) +0))) *hy)) bold_pixel(xp, yp, color_wave, 3) # 直線部分を描く z1 = [zone_xs[ws] +xb +0, zone_ys[ws] +yb +0] z2 = [zone_xs[ws] +xb +0, zone_ys[ws] +yb +hy] z3 = [zone_xs[ws] +xb +48, zone_ys[ws] +yb +hy*2] z4 = [zone_xs[ws] +xb +48, zone_ys[ws] +yb +hy] bold_line(z1, z2, color_wave) bold_line(z3, z4, color_wave) elif ws == 8: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) # 円周360度を 60分割してサイン波形をプロットする for i in range(wx): xp = zone_xs[ws] +i +xb y = -int(math.sin(math.radians(i *(360/wx))) *hy) # 上限・下限を設ける if y > 11: y = 11 elif y < -11: y = -11 yp = zone_yl[ws] +y bold_pixel(xp, yp, color_wave, 3) elif ws == 9: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) # 円周360度を 60分割してサイン波形をプロットする for i in range(int(wx/2)+1): xp = zone_xs[ws] +i +xb y = -int(math.sin(math.radians(i *(360/wx))) *hy) # 上限・下限を設ける if y > 11: y = 11 elif y < -11: y = -11 yp = zone_yl[ws] +y bold_pixel(xp, yp, color_wave, 3) z1 = [zone_xs[ws] +xb +24, zone_ys[ws] +yb +hy] z2 = [zone_xs[ws] +xb +48, zone_ys[ws] +yb +hy] bold_line(z1, z2, color_wave) elif ws == 10: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) # 円周360度を 60分割してサイン波形をプロットする for i in range(wx): xp = zone_xs[ws] +i +xb y = -int(abs(math.sin(math.radians(i *(360/wx))) *hy)) # 上限・下限を設ける if y > 11: y = 11 elif y < -11: y = -11 yp = zone_yl[ws] +y bold_pixel(xp, yp, color_wave, 3) elif ws == 11: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) # 円周360度を 60分割してサイン波形の 1/4 をプロットする for i in range(0, 12): xp = zone_xs[ws] +i +xb y = -int(abs(math.sin(math.radians(i *(360/wx))) *hy)) # 上限・下限を設ける if y > 11: y = 11 elif y < -11: y = -11 yp = zone_yl[ws] +y bold_pixel(xp, yp, color_wave, 3) # 円周360度を 60分割してサイン波形の 3/4 をプロットする for i in range(24, 36): xp = zone_xs[ws] +i +xb y = -int(abs(math.sin(math.radians(i *(360/wx))) *hy)) # 上限・下限を設ける if y > 11: y = 11 elif y < -11: y = -11 yp = zone_yl[ws] +y bold_pixel(xp, yp, color_wave, 3) # 直線部分を描く z1 = [zone_xs[ws] +xb +12, zone_ys[ws] +yb +5] z2 = [zone_xs[ws] +xb +12, zone_ys[ws] +yb +hy] z3 = [zone_xs[ws] +xb +24, zone_ys[ws] +yb +hy] bold_line(z1, z2, color_wave) bold_line(z2, z3, color_wave) z4 = [zone_xs[ws] +xb +36, zone_ys[ws] +yb +5] z5 = [zone_xs[ws] +xb +36, zone_ys[ws] +yb +hy] z6 = [zone_xs[ws] +xb +48, zone_ys[ws] +yb +hy] bold_line(z4, z5, color_wave) bold_line(z5, z6, color_wave) elif ws == 12: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) # 円周360度を 60分割してサイン波形をプロットする for i in range(30+1): xp = zone_xs[ws] +i +xb *2 y = -int(math.sin(math.radians(i *(360/30))) *hy) # 上限・下限を設ける if y > 11: y = 11 elif y < -11: y = -11 yp = zone_yl[ws] +y bold_pixel(xp, yp, color_wave, 3) elif ws == 13: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) # 円周360度を 60分割してサイン波形をプロットする for i in range(30+1): xp = zone_xs[ws] +i +xb *2 y = -int(abs(math.sin(math.radians(i *(360/30))) *hy)) # 上限・下限を設ける if y > 11: y = 11 elif y < -11: y = -11 yp = zone_yl[ws] +y bold_pixel(xp, yp, color_wave, 3) elif ws == 14: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) # 直線部分を描く xp = zone_xs[ws] +xb yp = zone_yl[ws] zl = [[xp,yp], [0,+hy], [24,+hy], [24,0], [48,0]] one_write_line(zl, color_wave) elif ws == 15: # Notthing pass elif ws == 16: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) # 直線部分を描く xp = zone_xs[ws] +xb yp = zone_yl[ws] zl = [[xp,yp], [12,+hy], [36,-hy], [48,0]] one_write_line(zl, color_wave) elif ws == 17: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) # 直線部分を描く xp = zone_xs[ws] +xb yp = zone_yl[ws] zl = [[xp,yp], [12,+hy], [24,0], [48,0]] one_write_line(zl, color_wave) elif ws == 18: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) # 直線部分を描く xp = zone_xs[ws] +xb yp = zone_yl[ws] zl = [[xp,yp], [12,+hy], [24,0], [36,+hy], [48,0]] one_write_line(zl, color_wave) elif ws == 19: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) # 直線部分を描く xp = zone_xs[ws] +xb yp = zone_yl[ws] zl = [[xp,yp], [12,+hy], [12,0], [24,0], [36,+hy], [36,0], [48,0]] one_write_line(zl, color_wave) elif ws == 20: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) # 直線部分を描く xp = zone_xs[ws] +xb*2 yp = zone_yl[ws] zl = [[xp,yp], [7,+hy], [21,-hy], [28,0]] one_write_line(zl, color_wave) elif ws == 21: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) # 直線部分を描く xp = zone_xs[ws] +xb*2 yp = zone_yl[ws] zl = [[xp,yp], [7,+hy], [14,0], [21,+hy], [28,0]] one_write_line(zl, color_wave) elif ws == 22: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) # 直線部分を描く xp = zone_xs[ws] +xb yp = zone_yl[ws] # 起点 1 2 3 4 5 6 7 8 zl = [[xp,yp], [0,+hy], [12,+hy], [12,0], [24,0], [24,+hy], [36,+hy], [36,0], [48,0]] one_write_line(zl, color_wave) elif ws == 23: # Notthing pass elif ws == 24: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) # 直線部分を描く xp = zone_xs[ws] +xb yp = zone_yl[ws] zl = [[xp,yp], [24,+hy], [24,-hy], [48,0]] one_write_line(zl, color_wave) elif ws == 25: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) # 直線部分を描く xp = zone_xs[ws] +xb yp = zone_yl[ws] zl = [[xp,yp], [24,+hy], [24,0], [48,0]] one_write_line(zl, color_wave) elif ws == 26: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) # 直線部分を描く xp = zone_xs[ws] +xb yp = zone_yl[ws] zl = [[xp,yp], [24,+hy], [24,0], [48,+hy], [48,0]] one_write_line(zl, color_wave) elif ws == 27: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) # 直線部分を描く xp = zone_xs[ws] +xb yp = zone_yl[ws] zl = [[xp,yp], [12,+hy], [12,0], [24,0], [36,+hy], [36,0], [48,0]] one_write_line(zl, color_wave) elif ws == 28: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) # 直線部分を描く xp = zone_xs[ws] +xb*2 yp = zone_yl[ws] zl = [[xp,yp], [14,+hy], [14,-hy], [28,0]] one_write_line(zl, color_wave) elif ws == 29: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) # 直線部分を描く xp = zone_xs[ws] +xb*2 yp = zone_yl[ws] zl = [[xp,yp], [14,+hy], [14,0], [28,+hy], [28,0]] one_write_line(zl, color_wave) elif ws == 30: # 指定のセル枠を指定色で埋める LCD.fill_rect(zone_xs[ws],zone_ys[ws], w, h, color_back) # 直線部分を描く xp = zone_xs[ws] +xb*2 yp = zone_yl[ws] zl = [[xp,yp], [0,+hy], [12,+hy], [12,0], [36,0]] one_write_line(zl, color_wave) elif ws == 31: # Nothing pass def select_WS(tabM_num, tabS_num, OP_num, WS_num): # Main Tab の座標リストを取得 zoneMtab_s = TAB.get_zoneMtab_s() zoneMtab_e = TAB.get_zoneMtab_e() # Sub Tab の座標リストを取得 zoneStab_s = TAB.get_zoneStab_s() zoneStab_e = TAB.get_zoneStab_e() # ALG op1 ~ op4 の座標リストを取得 zOPs = TAB.get_zOPs() zOPe = TAB.get_zOPe() # 上段表示エリアの開始座標と終末座標を取得 zUPs = TAB.get_zUPs() zUPe = TAB.get_zUPe() # 下段表示エリアの開始座標と終末座標を取得 zLWs = TAB.get_zLWs() zLWe = TAB.get_zLWe() WS_max = 31 # 下段の表示領域をクリア dspFillLower(LCD.WHITE) # ws 全波形の表示 ★★★ zWSs zWSe がセットされる for ws in range(WS_max): wave_form(ws, LCD.WHITE, LCD.BLACK) # WS_num をハイライト wave_form(WS_num, LCD.YELLOW, LCD.BLACK) LCD.show() # WS:0 ~ WS:30 の座標リストを取得 ★★★ wave_form() を先に」実行すること zWSs = TAB.get_zWSs() zWSe = TAB.get_zWSe() # cnt_zone{n] の初期化 cnt_zone = [None] * WS_max for i in range(WS_max): cnt_zone[i] = 0 # cnt_tabM cnt_tabS cntOP の初期化 cnt_tabM = [None] * 5 cnt_tabS = [None] * 5 cnt_OP = [None] * 5 for i in range(5): cnt_tabM[i] = 0 cnt_tabS[i] = 0 cnt_OP[i] = 0 WS_num_old = WS_num # 終了条件の設定 tabM_num_old = tabM_num tabS_num_old = tabS_num OP_num_old = OP_num while tabM_num_old == tabM_num and tabS_num_old == tabS_num and OP_num_old == OP_num: # 右下に WS 番号を表示 dspWS(WS_num) get = LCD.touch_get() if get != None: # タッチされているなら X_Point = get[0] Y_Point = get[1] # 下段表示エリアか？ if in_zone(zLWs, zLWe, X_Point, Y_Point): for i in range(WS_max): if in_zone(zWSs[i], zWSe[i], X_Point, Y_Point): # zWS[i] の周辺ならば # print(f'select zWS[{i}]') cnt_zone[i] += 1 if cnt_zone[i] == TOUCH_TH: WS_num = i print(f'WS Select = {WS_num}') if not(WS_num >= WS_max or WS_num == 15 or WS_num == 23): # 直前の WS の表示をハイライトではない表示に wave_form(WS_num_old, LCD.WHITE, LCD.BLACK) # 選択された WS をハイライト表示 wave_form(WS_num, LCD.YELLOW, LCD.RED) # 右下に WS 番号を表示 dspWS(WS_num) WS_num_old = WS_num # mainTab のタッチで終了 if in_zone(zoneMtab_s[1], zoneMtab_e[4], X_Point, Y_Point): for i in range(1, 5): if in_zone(zoneMtab_s[i], zoneMtab_e[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば cnt_tabM[i] += 1 if cnt_tabM[i] == TOUCH_TH: tabM_num = i print(f'main-menu Select = {tabM_num}') # subTab のタッチで終了 if in_zone(zoneStab_s[1], zoneStab_e[4], X_Point, Y_Point): for i in range(1, 5): if in_zone(zoneStab_s[i], zoneStab_e[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば cnt_tabS[i] += 1 if cnt_tabS[i] == TOUCH_TH: tabS_num = i print(f'sub-menu Select = {tabS_num}') # OP のタッチで終了 # 上段表示エリアか？ if in_zone(zUPs, zUPe, X_Point, Y_Point): for i in range(1, 5): if in_zone(zOPs[i], zOPe[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば cnt_OP[i] += 1 if cnt_OP[i] == TOUCH_TH: OP_num = i # 現在の OP 以外を選択なら表示する。現在の OP を選択なら表示しない。 if OP_num_old != OP_num: print(f'ALG OP Select = {OP_num}') else: # cnt_zone{n] の初期化 for i in range(WS_max): cnt_zone[i] = 0 # cnt_tabM cnt_tabS cntOP の初期化 for i in range(5): cnt_tabM[i] = 0 cnt_tabS[i] = 0 cnt_OP[i] = 0 LCD.show() return (tabM_num, tabS_num, OP_num, WS_num) # ADSR 編集 # 2025/11/03 ymf825.Voice_Op_Edit[MUL][OP_num] を追加、表示のみ def edit_adsr(tabM_num, tabS_num, OP_num, now_TL, now_SL, now_AR, now_DR, now_SR, now_RR, \ now_KSL, now_KSR, now_MUL): # 座標リストの取得 # Main Tab zoneMtab_s = TAB.get_zoneMtab_s() zoneMtab_e = TAB.get_zoneMtab_e() # Sub Tab zoneStab_s = TAB.get_zoneStab_s() zoneStab_e = TAB.get_zoneStab_e() # ALG op1 ~ op4 zOPs = TAB.get_zOPs() zOPe = TAB.get_zOPe() # 上段表示エリアの開始座標と終末座標を取得 zUPs = TAB.get_zUPs() zUPe = TAB.get_zUPe() # 下段表示エリアの開始座標と終末座標を取得 zLWs = TAB.get_zLWs() zLWe = TAB.get_zLWe() # 使用するゾーンリストの生成 zone_ARTLs = [None] *2 zone_ARTLe = [None] *2 zone_DRSLs = [None] *2 zone_DRSLe = [None] *2 zone_SRs = [None] *2 zone_SRe = [None] *2 zone_RRs = [None] *2 zone_RRe = [None] *2 guide_ARTLs = [None] *2 guide_ARTLe = [None] *2 guide_DRSLs = [None] *2 guide_DRSLe = [None] *2 guide_SRs = [None] *2 guide_SRe = [None] *2 guide_RRs = [None] *2 guide_RRe = [None] *2 cnt_ARTL = 0 cnt_SL = 0 cnt_DRSL = 0 cnt_SR = 0 cnt_RR = 0 cnt_KSL0 = 0 cnt_KSL1 = 0 cnt_KSL2 = 0 cnt_KSL3 = 0 cnt_KSR0 = 0 cnt_KSR1 = 0 # cnt_tabM cnt_tabS cntOP の初期化 cnt_tabM = [None] * 5 cnt_tabS = [None] * 5 cnt_OP = [None] * 5 for i in range(5): cnt_tabM[i] = 0 cnt_tabS[i] = 0 cnt_OP[i] = 0 # 終了条件の設定 tabM_num_old = tabM_num tabS_num_old = tabS_num OP_num_old = OP_num edt_mode = '' flag_begin = 1 while tabM_num_old == tabM_num and tabS_num_old == tabS_num and OP_num_old == OP_num: # 下面の編集 # スライダーポイントの座標設定（Pixcel単位）：縮小値 pos_KEYON = [0, 63] # pos_KEYON = [0, 63] pos_ARTL = [23 -now_AR, now_TL] # pos_DRSL = [47 -now_DR, now_TL +now_SL] # pos_ARTL と重ならないよう右に 4 Pixel シフト pos_DRSL = [(23 -now_AR) + (15 -now_DR) +4, now_TL +now_SL] pos_SR = [55, now_TL +now_SL +now_SR] pos_RR = [79 -now_RR, 63] # 座標位置を３倍の位置に展開 pos_KEYON = [ADSRxs +pos_KEYON[0] *3, ADSRys +pos_KEYON[1] *3] pos_ARTL = [ADSRxs +pos_ARTL[0] *3, ADSRys +pos_ARTL[1] *3] pos_DRSL = [ADSRxs +pos_DRSL[0] *3, ADSRys +pos_DRSL[1] *3] pos_SR = [ADSRxs +pos_SR[0] *3, ADSRys +pos_SR[1] *3] pos_RR = [ADSRxs +pos_RR[0] *3, ADSRys +pos_RR[1] *3] # タッチペンで触れた時に反応するゾーンの設定 zone_ARTLs[0] = 0 if pos_ARTL[0] < TOUCH else pos_ARTL[0] - TOUCH zone_ARTLs[1] = 0 if pos_ARTL[1] < TOUCH else pos_ARTL[1] - TOUCH zone_ARTLe[0] = 319 if (pos_ARTL[0] + TOUCH) >= 320 else pos_ARTL[0] + TOUCH zone_ARTLe[1] = 479 if (pos_ARTL[1] + TOUCH) >= 480 else pos_ARTL[1] + TOUCH zone_DRSLs[0] = 0 if pos_DRSL[0] < TOUCH else pos_DRSL[0] - TOUCH zone_DRSLs[1] = 0 if pos_DRSL[1] < TOUCH else pos_DRSL[1] - TOUCH zone_DRSLe[0] = 319 if (pos_DRSL[0] + TOUCH) >= 320 else pos_DRSL[0] + TOUCH zone_DRSLe[1] = 479 if (pos_DRSL[1] + TOUCH) >= 480 else pos_DRSL[1] + TOUCH zone_SRs[0] = 0 if pos_SR[0] < TOUCH else pos_SR[0] - TOUCH zone_SRs[1] = 0 if pos_SR[1] < TOUCH else pos_SR[1] - TOUCH zone_SRe[0] = 319 if (pos_SR[0] + TOUCH) >= 320 else pos_SR[0] + TOUCH zone_SRe[1] = 479 if (pos_SR[1] + TOUCH) >= 480 else pos_SR[1] + TOUCH # パネルの周囲は精度が出ないので倍の大きさにする。 zone_RRs[0] = 0 if pos_RR[0] < TOUCH *2 else pos_RR[0] - TOUCH *2 zone_RRs[1] = 0 if pos_RR[1] < TOUCH *2 else pos_RR[1] - TOUCH *2 zone_RRe[0] = 319 if (pos_RR[0] + TOUCH *2) >= 320 else pos_RR[0] + TOUCH *2 zone_RRe[1] = 479 if (pos_RR[1] + TOUCH *2) >= 480 else pos_RR[1] + TOUCH *2 ######################################################################## # AR TL 操作可能エリア slide_ARTLs = [23 -max_AR, 0] # slide_ARTLe = [23 +2, max_TL +2] slide_ARTLe = [23, max_TL] # DR SL 操作可能エリア pos_ARTL と重ならないよう右に 4 Pixel シフト slide_DRSLs = [(23 -now_AR) +4, now_TL] # slide_DRSLe = [(23 -now_AR) +4 +max_DR +2, now_TL +max_SL +2] slide_DRSLe = [(23 -now_AR) +4 +max_DR, now_TL +max_SL] # SR 直線上の設定範囲 slide_SRs = [55, now_TL +now_SL] slide_SRe = [55, now_TL +now_SL +max_SR +2] # RR 直線上の設定範囲 slide_RRs = [63, 63] slide_RRe = [63 +max_RR, 63] # 操作ガイドを３倍の位置に展開 slide_ARTLs = [ADSRxs +slide_ARTLs[0] *3, ADSRys +slide_ARTLs[1] *3] slide_ARTLe = [ADSRxs +slide_ARTLe[0] *3, ADSRys +slide_ARTLe[1] *3] slide_ARTLw = slide_ARTLe[0] - slide_ARTLs[0] slide_ARTLh = slide_ARTLe[1] - slide_ARTLs[1] slide_DRSLs = [ADSRxs +slide_DRSLs[0] *3, ADSRys +slide_DRSLs[1] *3] slide_DRSLe = [ADSRxs +slide_DRSLe[0] *3, ADSRys +slide_DRSLe[1] *3] slide_DRSLw = slide_DRSLe[0] - slide_DRSLs[0] slide_DRSLh = slide_DRSLe[1] - slide_DRSLs[1] slide_SRs = [ADSRxs +slide_SRs[0] *3, ADSRys +slide_SRs[1] *3] slide_SRe = [ADSRxs +slide_SRe[0] *3, ADSRys +slide_SRe[1] *3] slide_RRs = [ADSRxs +slide_RRs[0] *3, ADSRys +slide_RRs[1] *3] slide_RRe = [ADSRxs +slide_RRe[0] *3, ADSRys +slide_RRe[1] *3] # 長方形の操作可能範囲 16 Pixcel guide_ARTLs[0] = 0 if slide_ARTLs[0] < TOUCH else slide_ARTLs[0] - TOUCH guide_ARTLs[1] = 0 if slide_ARTLs[1] < TOUCH else slide_ARTLs[1] - TOUCH guide_ARTLe[0] = 319 if (slide_ARTLe[0] + TOUCH) >= 320 else slide_ARTLe[0] + TOUCH guide_ARTLe[1] = 479 if (slide_ARTLe[1] + TOUCH) >= 480 else slide_ARTLe[1] + TOUCH guide_DRSLs[0] = 0 if slide_DRSLs[0] < TOUCH else slide_DRSLs[0] - TOUCH guide_DRSLs[1] = 0 if slide_DRSLs[1] < TOUCH else slide_DRSLs[1] - TOUCH guide_DRSLe[0] = 319 if (slide_DRSLe[0] + TOUCH) >= 320 else slide_DRSLe[0] + TOUCH guide_DRSLe[1] = 479 if (slide_DRSLe[1] + TOUCH) >= 480 else slide_DRSLe[1] + TOUCH guide_SRs[0] = 0 if slide_SRs[0] < TOUCH *2 else slide_SRs[0] - TOUCH *2 guide_SRs[1] = 0 if slide_SRs[1] < TOUCH else slide_SRs[1] - TOUCH guide_SRe[0] = 319 if (slide_SRe[0] + TOUCH) >= 320 else slide_SRe[0] + TOUCH guide_SRe[1] = 479 if (slide_SRe[1] + TOUCH) >= 480 else slide_SRe[1] + TOUCH guide_RRs[0] = 0 if slide_RRs[0] < TOUCH *2 else slide_RRs[0] - TOUCH *2 guide_RRs[1] = 0 if slide_RRs[1] < TOUCH *2 else slide_RRs[1] - TOUCH *2 guide_RRe[0] = 319 if (slide_RRe[0] + TOUCH) >= 320 else slide_RRe[0] + TOUCH guide_RRe[1] = 479 if (slide_RRe[1] + TOUCH) >= 480 else slide_RRe[1] + TOUCH dspFillLower(LCD.WHITE) # AR TL 操作ガイドを表示 LCD.fill_rect(slide_ARTLs[0], slide_ARTLs[1], slide_ARTLw, slide_ARTLh, LCD.YELLOW) # SR SL 操作ガイドを表示 LCD.fill_rect(slide_DRSLs[0], slide_DRSLs[1], slide_DRSLw, slide_DRSLh, LCD.BLUEGREEN) # slide Line 水平方向のガイド（水平方向に５回線を引く） # RR for y in range(5): # LCD.line(slide_RRs[0], slide_RRs[1]+y, slide_RRe[0]+4, slide_RRe[1]+y, LCD.GREEN) LCD.line(slide_RRs[0] -2, slide_RRs[1]+y -2, slide_RRe[0] +2, slide_RRe[1]+y -2, LCD.GREEN) # slide Line 垂直方向のガイド（垂直方向に５回線を引く） # SR for x in range(5): # LCD.line(slide_SRs[0]+x, slide_SRs[1], slide_SRe[0]+x, slide_SRe[1]+4, LCD.GREEN) LCD.line(slide_SRs[0]+x -2, slide_SRs[1] -2, slide_SRe[0]+x -2, slide_SRe[1] +2, LCD.GREEN) # ADSR Line for x in range(-2, 3): for y in range(-2, 3): LCD.line(pos_KEYON[0]+x, pos_KEYON[1]+y, pos_ARTL[0]+x, pos_ARTL[1]+y, LCD.BLUE) LCD.line(pos_ARTL[0]+x, pos_ARTL[1]+y, pos_DRSL[0]+x, pos_DRSL[1]+y, LCD.BLUE) LCD.line(pos_DRSL[0]+x, pos_DRSL[1]+y, pos_SR[0]+x, pos_SR[1]+y, LCD.BLUE) LCD.line(pos_SR[0]+x, pos_SR[1]+y, pos_RR[0]+x, pos_RR[1]+y, LCD.BLUE) # AR・TL DR・SL SR RR の操作ポイント（サイズ 8x8）を表示する LCD.fill_rect(pos_ARTL[0] -4, pos_ARTL[1] -4, TOUCH, TOUCH, LCD.RED) LCD.fill_rect(pos_DRSL[0] -4, pos_DRSL[1] -4, TOUCH, TOUCH, LCD.RED) LCD.fill_rect(pos_SR[0] -4, pos_SR[1] -4, TOUCH, TOUCH, LCD.RED) LCD.fill_rect(pos_RR[0] -4, pos_RR[1] -4, TOUCH, TOUCH, LCD.RED) # AR TL SL DR SR RR の数値を表示する（編集中に再表示することに留意） dspAR(now_AR) dspRR(now_RR) dspTL(now_TL) dspDR(now_DR) dspSL(now_SL) dspSR(now_SR) # 2025/11/03 MUL 表示追加（編集はしない） dspMUL2(now_MUL) # KSL タッチゾーンの設定 zone_KSL0s = [10,ADSRys+130] zone_KSL0e = [zone_KSL0s[0] +16*3,zone_KSL0s[1]+20] zone_KSL1s = [10,ADSRys+90] zone_KSL1e = [zone_KSL1s[0] +16*3,zone_KSL1s[1]+20] zone_KSL2s = [10,ADSRys+110] zone_KSL2e = [zone_KSL2s[0] +16*3,zone_KSL2s[1]+20] zone_KSL3s = [10,ADSRys+70] zone_KSL3e = [zone_KSL3s[0] +16*3,zone_KSL3s[1]+20] # KSL の表示 LCD.text_scaled(f'KSL', 10,320,LCD.BLACK, 2) # KSL 数値表示 文字領域を 緑色にしてから表示、文字色は一旦灰色 LCD.fill_rect(10,ADSRys+70,16*3,20*4, LCD.GREEN) LCD.text_scaled(f'6.0', 10,ADSRys+70 +2,LCD.GRAY, 2) # KSL=3 LCD.text_scaled(f'3.0', 10,ADSRys+90 +2,LCD.GRAY, 2) # KSL=1 LCD.text_scaled(f'1.5', 10,ADSRys+110 +2,LCD.GRAY, 2) # KSL=2 LCD.text_scaled(f'0.0', 10,ADSRys+130 +2,LCD.GRAY, 2) # KSL=0 # KSL 設定値の表示 dsp_KSL(now_KSL) # KSR タッチゾーンの設定 zone_KSR0s = [260,ADSRys+120] zone_KSR0e = [zone_KSR0s[0] +16*3,zone_KSR0s[1]+20] zone_KSR1s = [260,ADSRys+100] zone_KSR1e = [zone_KSR1s[0] +16*3,zone_KSR1s[1]+20] # KSR エリアの表示 LCD.text_scaled(f'KSR',260,ADSRys+80,LCD.BLACK, 2) # KSR 数値表示 文字領域を 緑色にしてから表示、文字色は一旦灰色 LCD.fill_rect(260,ADSRys+100,16*3,20*2, LCD.GREEN) LCD.text_scaled(f'on',260,ADSRys+100,LCD.GRAY, 2) # KSR=1 LCD.text_scaled(f'off',260,ADSRys+120,LCD.GRAY, 2) # KSR=0 dsp_KSR(now_KSR) get = LCD.touch_get() if get != None: # タッチされているなら X_Point = get[0] Y_Point = get[1] if edt_mode == '': if in_zone(zone_ARTLs, zone_ARTLe, X_Point, Y_Point): # AR・TL ポイント周辺ならば # print('zone_ARTL') cnt_ARTL += 1 if cnt_ARTL == TOUCH_TH: # 差分検出用に現在値を記録（Pixcel値） edt_Xs = X_Point edt_Ys = Y_Point edt_mode = 'ARTL' print("edt_mode = 'ARTL'") elif in_zone(zone_DRSLs, zone_DRSLe, X_Point, Y_Point): # DR・SL ポイント周辺ならば # print('zone_DRSL') cnt_DRSL += 1 if cnt_DRSL == TOUCH_TH: # 差分検出用に現在値を記録（Pixcel値） edt_Xs = X_Point edt_Ys = Y_Point edt_mode = 'DRSL' print("edt_mode = 'DRSL'") elif in_zone(zone_RRs, zone_RRe, X_Point, Y_Point): # RR ポイント周辺ならば # print('zone_RR') cnt_RR += 1 if cnt_RR == TOUCH_TH: # 差分検出用に現在値を記録（Pixcel値） edt_Xs = X_Point edt_Ys = Y_Point edt_mode = 'RR' print("edt_mode = 'RR'") elif in_zone(zone_SRs, zone_SRe, X_Point, Y_Point): # SR ポイント周辺ならば # print('zone_SR') cnt_SR += 1 if cnt_SR == TOUCH_TH: # 差分検出用に現在値を記録（Pixcel値） edt_Xs = X_Point edt_Ys = Y_Point edt_mode = 'SR' print("edt_mode = 'SR'") elif in_zone(zone_KSL0s, zone_KSL0e, X_Point, Y_Point): # KSL0 ポイントならば # print('zone_KSL0') cnt_KSL0 += 1 if cnt_KSL0 == TOUCH_TH: now_KSL = 0 print('select_KSL0') # KSL 数値表示 背景を黄色にし、文字色は紫色 dsp_KSL(now_KSL) elif in_zone(zone_KSL1s, zone_KSL1e, X_Point, Y_Point): # KSL1 ポイントならば # print('zone_KSL1') cnt_KSL1 += 1 if cnt_KSL1 == TOUCH_TH: now_KSL = 1 print('select_KSL1') # KSL 数値表示 背景を黄色にし、文字色は紫色 dsp_KSL(now_KSL) elif in_zone(zone_KSL2s, zone_KSL2e, X_Point, Y_Point): # KSL2 ポイントならば # print('zone_KSL2') cnt_KSL2 += 1 if cnt_KSL2 == TOUCH_TH: now_KSL = 2 print('select_KSL2') # KSL 数値表示 背景を黄色にし、文字色は紫色 dsp_KSL(now_KSL) elif in_zone(zone_KSL3s, zone_KSL3e, X_Point, Y_Point): # KSL3 ポイントならば # print('zone_KSL3') cnt_KSL3 += 1 if cnt_KSL3 == TOUCH_TH: now_KSL = 3 print('select_KSL3') # KSL 数値表示 背景を黄色にし、文字色は紫色 dsp_KSL(now_KSL) elif in_zone(zone_KSR0s, zone_KSR0e, X_Point, Y_Point): # KSR0 ポイントならば # print('zone_KSR0') cnt_KSR0 += 1 if cnt_KSR0 == TOUCH_TH: now_KSR = 0 print('select_KSR0') # KSL 数値表示 背景を黄色にし、文字色は紫色 dsp_KSR(now_KSR) elif in_zone(zone_KSR1s, zone_KSR1e, X_Point, Y_Point): # KSR1 ポイントならば # print('zone_KSR1') cnt_KSR1 += 1 if cnt_KSR1 == TOUCH_TH: now_KSR = 1 print('select_KSR1') # KSL 数値表示 背景を黄色にし、文字色は紫色 dsp_KSR(now_KSR) # mainTab のタッチで終了 elif in_zone(zoneMtab_s[1], zoneMtab_e[4], X_Point, Y_Point): for i in range(1, 5): if in_zone(zoneMtab_s[i], zoneMtab_e[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば # print(f'select zoneMtab[{i}]') cnt_tabM[i] += 1 if cnt_tabM[i] >= TOUCH_TH: tabM_num = i print(f'main-menu Select = {tabM_num}') # subTab のタッチで終了 elif in_zone(zoneStab_s[1], zoneStab_e[4], X_Point, Y_Point): for i in range(1, 5): if in_zone(zoneStab_s[i], zoneStab_e[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば # print(f'select zoneStab[{i}]') cnt_tabS[i] += 1 if cnt_tabS[i] >= TOUCH_TH: tabS_num = i print(f'sub-menu Select = {tabS_num}') # OP のタッチで終了 # 上段表示エリアか？ elif in_zone(zUPs, zUPe, X_Point, Y_Point): for i in range(1, 5): if in_zone(zOPs[i], zOPe[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば # print(f'select zOP[{i}]') cnt_OP[i] += 1 if cnt_OP[i] >= TOUCH_TH: OP_num = i print(f'ALG OP Select = {OP_num}') elif edt_mode == 'RR': if in_zone(guide_RRs, guide_RRe, X_Point, Y_Point): # RR 編集ゾーンならば # print('edt_mode RR') if edt_Xs != X_Point: # 操作感度を上げる edt_def = int((X_Point - edt_Xs) /3) now_RR -= edt_def # 範囲に収める処理 now_RR = 0 if now_RR < 0 else now_RR now_RR = 15 if now_RR > 15 else now_RR # RR ポジション更新 計算方法は項目ごとに異なるので注意 pos_RR = [79 -now_RR, 63] # 座標位置を３倍の位置に展開 pos_RR = [ADSRxs +pos_RR[0] *3, ADSRys +pos_RR[1] *3] # RR ポインタ 倍角で表示 LCD.fill_rect(pos_RR[0] -TOUCH, pos_RR[1] -TOUCH, TOUCH *2, TOUCH *2, LCD.PURPLE) # RR 数値表示 文字領域を 白色にしてから表示 dspRR(now_RR) # edt_Xs 更新 edt_Xs = pos_RR[0] elif edt_mode == 'SR': if in_zone(guide_SRs, guide_SRe, X_Point, Y_Point): # SR 編集ゾーンならば # print('edt_mode SR') if edt_Ys != Y_Point: # 操作感度を上げる edt_def = int((Y_Point - edt_Ys) /3) now_SR += edt_def # 範囲に収める処理 now_SR = 0 if now_SR < 0 else now_SR now_SR = 15 if now_SR > 15 else now_SR # SR ポジション更新 計算方法は項目ごとに異なるので注意 pos_SR = [55, now_TL +now_SL +now_SR] # 座標位置を３倍の位置に展開 pos_SR = [ADSRxs +pos_SR[0] *3, ADSRys +pos_SR[1] *3] # SR ポインタ 倍角で表示 LCD.fill_rect(pos_SR[0] -TOUCH, pos_SR[1] -TOUCH, TOUCH *2, TOUCH *2, LCD.PURPLE) # SR 数値表示 文字領域を 白色にしてから表示 dspSR(now_SR) # edt_Xs 更新 edt_Ys = pos_SR[1] elif edt_mode == 'DRSL': if in_zone(guide_DRSLs, guide_DRSLe, X_Point, Y_Point): # DR 編集ゾーンならば # print('edt_mode DRSL') if edt_Ys != Y_Point: # 操作感度を下げる edt_def_X = int((X_Point - edt_Xs) /3) edt_def_Y = int((Y_Point - edt_Ys) /3) now_DR -= edt_def_X now_SL += edt_def_Y # 範囲に収める処理 now_DR = 0 if now_DR < 0 else now_DR now_DR = 15 if now_DR > 15 else now_DR now_SL = 0 if now_SL < 0 else now_SL now_SL = 15 if now_SL > 15 else now_SL # DR ポジション更新 計算方法は項目ごとに異なるので注意 # pos_DRSL = [(23 -now_AR) + (15 -now_DR), now_TL +now_SL] pos_DRSL = [(23 -now_AR) + (15 -now_DR) +4, now_TL +now_SL] # 座標位置を３倍の位置に展開 pos_DRSL = [ADSRxs +pos_DRSL[0] *3, ADSRys +pos_DRSL[1] *3] # DR ポインタ 倍角で表示 # LCD.fill_rect(pos_DRSL[0], pos_DRSL[1], 16, 16, LCD.PURPLE) LCD.fill_rect(pos_DRSL[0] -TOUCH, pos_DRSL[1] -TOUCH, TOUCH *2, TOUCH *2, LCD.PURPLE) # SL 数値表示 文字領域を 白色にしてから表示 dspSL(now_SL) # DR 数値表示 文字領域を 白色にしてから表示 dspDR(now_DR) # edt_Xs 更新 edt_Xs = pos_DRSL[0] edt_Ys = pos_DRSL[1] ######################################################################## elif edt_mode == 'ARTL': if in_zone(guide_ARTLs, guide_ARTLe, X_Point, Y_Point): # DR 編集ゾーンならば # print('edt_mode ARTL') if edt_Ys != Y_Point: # 操作感度を下げる edt_def_X = int((X_Point - edt_Xs) /3) edt_def_Y = int((Y_Point - edt_Ys) /3) now_AR -= edt_def_X now_TL += edt_def_Y # 範囲に収める処理 now_AR = 0 if now_AR < 0 else now_AR now_AR = 15 if now_AR > 15 else now_AR now_TL = 0 if now_TL < 0 else now_TL now_TL = max_TL if now_TL > max_TL else now_TL # ARTL ポジション更新 計算方法は項目ごとに異なるので注意 pos_ARTL = [23 -now_AR, now_TL] # 座標位置を３倍の位置に展開 pos_ARTL = [ADSRxs +pos_ARTL[0] *3, ADSRys +pos_ARTL[1] *3] # AR・TL ポインタ 倍角で表示 # LCD.fill_rect(pos_ARTL[0], pos_ARTL[1], 8, 8, LCD.PURPLE) LCD.fill_rect(pos_ARTL[0] -TOUCH, pos_ARTL[1] -TOUCH, TOUCH *2, TOUCH *2, LCD.PURPLE) # AR 数値表示 文字領域を 白色にしてから表示 dspAR(now_AR) # TL 数値表示 文字領域を 白色にしてから表示 dspTL(now_TL) # edt_Xs 更新 edt_Xs = pos_ARTL[0] edt_Ys = pos_ARTL[1] ######################################################################## else: # get == None edt_mode = '' # 最初は必ず表示する。以降はタッチがなければ、表示するように変更 flag_begin = 0 cnt_ARTL = 0 cnt_SL = 0 cnt_DRSL = 0 cnt_SR = 0 cnt_RR = 0 cnt_KSL0 = 0 cnt_KSL1 = 0 cnt_KSL2 = 0 cnt_KSL3 = 0 cnt_KSR0 = 0 cnt_KSR1 = 0 # cnt_tabM cnt_tabS cntOP の初期化 for i in range(5): cnt_tabM[i] = 0 cnt_tabS[i] = 0 cnt_OP[i] = 0 LCD.show() return(tabM_num, tabS_num, OP_num, now_TL, now_SL, now_AR, now_DR, now_SR, now_RR, now_KSL, now_KSR) # MUL DT FB XOF の編集 def edit_mul(tabM_num, tabS_num, OP_num, now_MUL, now_DT, now_FB, now_XOF): # Main Tab の座標リストを取得 zoneMtab_s = TAB.get_zoneMtab_s() zoneMtab_e = TAB.get_zoneMtab_e() # Sub Tab の座標リストを取得 zoneStab_s = TAB.get_zoneStab_s() zoneStab_e = TAB.get_zoneStab_e() # ALG op1 ~ op4 の座標リストを取得 zOPs = TAB.get_zOPs() zOPe = TAB.get_zOPe() # 上段表示エリアの開始座標と終末座標を取得 zUPs = TAB.get_zUPs() zUPe = TAB.get_zUPe() # 下段表示エリアの開始座標と終末座標を取得 zLWs = TAB.get_zLWs() zLWe = TAB.get_zLWe() cnt_MUL = 0 cnt_DT = 0 # FB タッチゾーンの設定 # FB タッチ開始座標は、main で設定したものを利用する zone_FBsi = [None, None] *(max_FB +1) zone_FBei = [None, None] *(max_FB +1) for i in range(max_FB +1): zone_FBsi[i] = [FBxs[i], FBys[i]] zone_FBei[i] = [FBxs[i]+16*6, FBys[i]+20] # FB カウンタの設定 cnt_FBi = [None] *(max_FB +1) for i in range(max_FB +1): cnt_FBi[i] = 0 # XOF タッチゾーンの設定 # XOF タッチ開始座標は、冒頭で設定したものを利用する zone_XOFsi = [None, None] *(max_XOF +1) zone_XOFei = [None, None] *(max_XOF +1) for i in range(max_XOF +1): zone_XOFsi[i] = [XOFxs[i], XOFys[i]] zone_XOFei[i] = [XOFxs[i]+16*6, XOFys[i]+20] # XOF カウンタの設定 cnt_XOFi = [None] *(max_XOF +1) for i in range(max_XOF +1): cnt_XOFi[i] = 0 # MUL DT 座標更新 # MUL DT スライダーポイントの座標設定（Pixcel単位）：絶対値 pos_MUL = [ 40, 445 - now_MUL *10] # MUL:0~15 pos_DT = [120, 445 - now_DT *10] # DT:0~7 # MUL DT タッチゾーン設定 16 Pixcel四方 ---> 24 Pixcel四方 zone_MULs = [None] *2 zone_MULs[0] = 0 if pos_MUL[0] < TOUCH *2 else pos_MUL[0] - TOUCH *2 zone_MULs[1] = 0 if pos_MUL[1] < TOUCH *2 else pos_MUL[1] - TOUCH *2 zone_MULe = [None] *2 zone_MULe[0] = 319 if (pos_MUL[0] + TOUCH) >= 320 else pos_MUL[0] + TOUCH zone_MULe[1] = 479 if (pos_MUL[1] + TOUCH) >= 480 else pos_MUL[1] + TOUCH zone_DTs = [None] *2 zone_DTs[0] = 0 if pos_DT[0] < TOUCH *2 else pos_DT[0] - TOUCH *2 zone_DTs[1] = 0 if pos_DT[1] < TOUCH *2 else pos_DT[1] - TOUCH *2 zone_DTe = [None] *2 zone_DTe[0] = 319 if (pos_DT[0] + TOUCH) >= 320 else pos_DT[0] + TOUCH zone_DTe[1] = 479 if (pos_DT[1] + TOUCH) >= 480 else pos_DT[1] + TOUCH ######################################################################## # MUL 直線上の設定範囲（Pixcel単位）：絶対値 slide_MULs = [ 40, 445 - max_MUL *10] slide_MULe = [ 40, 445] # DT 直線上の設定範囲（Pixcel単位）：絶対値 slide_DTs = [120, 445 - max_DT *10] slide_DTe = [120, 445] # 長方形の操作可能範囲 16 Pixcel guide_MULs = [None] *2 # 2025/07/21 Change # guide_MULs[0] = 0 if slide_MULs[0] < TOUCH else slide_MULs[0] - TOUCH guide_MULs[0] = 0 if slide_MULs[0] < TOUCH *2 else slide_MULs[0] - TOUCH *2 guide_MULs[1] = 0 if slide_MULs[1] < TOUCH else slide_MULs[1] - TOUCH guide_MULe = [None] *2 guide_MULe[0] = 319 if (slide_MULe[0] + TOUCH) >= 320 else slide_MULe[0] + TOUCH guide_MULe[1] = 479 if (slide_MULe[1] + TOUCH) >= 480 else slide_MULe[1] + TOUCH guide_DTs = [None] *2 # 2025/07/21 Change # guide_DTs[0] = 0 if slide_DTs[0] < TOUCH else slide_DTs[0] - TOUCH guide_DTs[0] = 0 if slide_DTs[0] < TOUCH *2 else slide_DTs[0] - TOUCH *2 guide_DTs[1] = 0 if slide_DTs[1] < TOUCH else slide_DTs[1] - TOUCH guide_DTe = [None] *2 guide_DTe[0] = 319 if (slide_DTe[0] + TOUCH) >= 320 else slide_DTe[0] + TOUCH guide_DTe[1] = 479 if (slide_DTe[1] + TOUCH) >= 480 else slide_DTe[1] + TOUCH # cnt_tabM cnt_tabS cntOP の初期化 cnt_tabM = [None] * 5 cnt_tabS = [None] * 5 cnt_OP = [None] * 5 for i in range(5): cnt_tabM[i] = 0 cnt_tabS[i] = 0 cnt_OP[i] = 0 # 終了条件の設定 tabM_num_old = tabM_num tabS_num_old = tabS_num OP_num_old = OP_num edt_mode = '' while tabM_num_old == tabM_num and tabS_num_old == tabS_num and OP_num_old == OP_num: # MUL DT 座標更新 # MUL DT スライダーポイントの座標設定（Pixcel単位）：絶対値 pos_MUL = [ 40, 445 - now_MUL *10] # MUL:0~15 pos_DT = [120, 445 - now_DT *10] # DT:0~7 # MUL DT タッチゾーン更新 16 Pixcel四方 ---> 24 Pixcel四方 # pos_MUL と pos_DT は、タッチで更新される zone_MULs[0] = 0 if pos_MUL[0] < TOUCH *2 else pos_MUL[0] - TOUCH *2 zone_MULs[1] = 0 if pos_MUL[1] < TOUCH *2 else pos_MUL[1] - TOUCH *2 zone_MULe[0] = 319 if (pos_MUL[0] + TOUCH) >= 320 else pos_MUL[0] + TOUCH zone_MULe[1] = 479 if (pos_MUL[1] + TOUCH) >= 480 else pos_MUL[1] + TOUCH zone_DTs[0] = 0 if pos_DT[0] < TOUCH *2 else pos_DT[0] - TOUCH *2 zone_DTs[1] = 0 if pos_DT[1] < TOUCH *2 else pos_DT[1] - TOUCH *2 zone_DTe[0] = 319 if (pos_DT[0] + TOUCH) >= 320 else pos_DT[0] + TOUCH zone_DTe[1] = 479 if (pos_DT[1] + TOUCH) >= 480 else pos_DT[1] + TOUCH dspFillLower(LCD.WHITE) # slide Line 垂直方向のガイド（垂直方向に５回線を引く） # MUL DT for x in range(-2, 3): # -2, -1, 0, 1, 2 : 38, 39, 40, 41, 42 : 118, 119, 120, 121, 122 LCD.line(slide_MULs[0]+x, slide_MULs[1], slide_MULe[0]+x, slide_MULe[1]+4, LCD.GREEN) LCD.line(slide_DTs[0]+x, slide_DTs[1], slide_DTe[0]+x, slide_DTe[1]+4, LCD.GREEN) # MUL DT の操作ポイントを、サイズ TOUCH（8x8）で再表示する LCD.fill_rect(pos_MUL[0] -4, pos_MUL[1] -4, TOUCH, TOUCH, LCD.RED) LCD.fill_rect(pos_DT[0] -4, pos_DT[1] -4, TOUCH, TOUCH, LCD.RED) # MUL のタイトル表示 LCD.text_scaled(f'MUL', 0 +16, 455, LCD.BLACK, 2) # DT のタイトル表示 LCD.text_scaled(f'DT', 80 +24, 455, LCD.BLACK, 2) # MUL DT の数値を表示する（編集中にも表示することに留意） dspMUL(now_MUL) dspDT(now_DT) # FB のタイトル表示 LCD.text_scaled(f'FB', 160+24, 455, LCD.BLACK, 2) # FB 数値表示 文字領域を 緑色にしてから表示、文字色は一旦灰色 for fb in range(max_FB +1): # FB 設定内容の表示 dsp_FB(fb, LCD.GREEN, LCD.GRAY) # FB 設定値の表示 dsp_FB(now_FB, LCD.YELLOW, LCD.PURPLE) # XOF のタイトル表示 LCD.text_scaled(f'XOF',250, 455, LCD.BLACK, 2) # XOF 数値表示 文字領域を 緑色にしてから表示、文字色は一旦灰色 for xof in range(max_XOF +1): # XOF 設定内容の表示 dsp_XOF(xof, LCD.GREEN, LCD.GRAY) # XOF 設定値の表示 dsp_XOF(now_XOF, LCD.YELLOW, LCD.PURPLE) get = LCD.touch_get() if get != None: # タッチされているなら X_Point = get[0] Y_Point = get[1] if edt_mode == '': if in_zone(zone_MULs, zone_MULe, X_Point, Y_Point): # MUL ポイント周辺ならば # print('zone_MUL') cnt_MUL += 1 if cnt_MUL == TOUCH_TH: print('select_MUL') # 差分検出用に現在値を記録（Pixcel値） edt_Ys = Y_Point edt_mode = 'MUL' elif in_zone(zone_DTs, zone_DTe, X_Point, Y_Point): # DT ポイント周辺ならば # print('zone_DT') cnt_DT += 1 if cnt_DT == TOUCH_TH: print('select_DT') # 差分検出用に現在値を記録（Pixcel値） edt_Ys = Y_Point edt_mode = 'DT' for i in range(max_FB +1): if in_zone(zone_FBsi[i], zone_FBei[i], X_Point, Y_Point): # print(f'zone_FB{i}') cnt_FBi[i] += 1 if cnt_FBi[i] == TOUCH_TH: # 差分検出用に現在値を記録（Pixcel値） edt_Xs = X_Point edt_Ys = Y_Point now_FB = i # FB 数値表示 背景を黄色にし、文字色は紫色 dsp_FB(now_FB, LCD.YELLOW, LCD.PURPLE) edt_mode = f'FB{i}' print(f'edt_mode = {edt_mode}') for i in range(max_XOF +1): if in_zone(zone_XOFsi[i], zone_XOFei[i], X_Point, Y_Point): # print(f'zone_XOF{i}') cnt_XOFi[i] += 1 if cnt_XOFi[i] == TOUCH_TH: # 差分検出用に現在値を記録（Pixcel値） edt_Xs = X_Point edt_Ys = Y_Point now_XOF = i # XOF 数値表示 背景を黄色にし、文字色は紫色 dsp_XOF(now_XOF, LCD.YELLOW, LCD.PURPLE) edt_mode = f'XOF{i}' print(f'edt_mode = {edt_mode}') # mainTab のタッチで終了 if in_zone(zoneMtab_s[1], zoneMtab_e[4], X_Point, Y_Point): for i in range(1, 5): if in_zone(zoneMtab_s[i], zoneMtab_e[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば # print(f'select zoneMtab[{i}]') cnt_tabM[i] += 1 if cnt_tabM[i] == TOUCH_TH: tabM_num = i print(f'main-menu Select = {tabM_num}') # subTab のタッチで終了 if in_zone(zoneStab_s[1], zoneStab_e[4], X_Point, Y_Point): for i in range(1, 5): if in_zone(zoneStab_s[i], zoneStab_e[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば # print(f'select zoneStab[{i}]') cnt_tabS[i] += 1 if cnt_tabS[i] == TOUCH_TH: tabS_num = i print(f'sub-menu Select = {tabS_num}') # OP のタッチで終了 # 上段表示エリアか？ if in_zone(zUPs, zUPe, X_Point, Y_Point): for i in range(1, 5): if in_zone(zOPs[i], zOPe[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば # print(f'select zOP[{i}]') cnt_OP[i] += 1 if cnt_OP[i] == TOUCH_TH: OP_num = i print(f'ALG OP Select = {OP_num}') elif edt_mode == 'MUL': if in_zone(guide_MULs, guide_MULe, X_Point, Y_Point): # MUL 編集ゾーンならば # print('edt_mode MUL') if edt_Ys != Y_Point: # 操作感度を上げる場合は、/4 の数字を小さく、下げる場合は、/4 の数字を大きく # edt_def = int((Y_Point - edt_Ys) /4) edt_def = int((Y_Point - edt_Ys) /8) # 加減算の正負に注意（x軸は右方向に正、y軸は下方向に正） now_MUL += (edt_def *sign_MUL) # 範囲に収める処理 now_MUL = 0 if now_MUL < 0 else now_MUL now_MUL = max_MUL if now_MUL > max_MUL else now_MUL # 表示ポイント更新 計算方法は項目ごとに異なるので注意 # スライダーポイントの座標設定（Pixcel単位）：絶対値 を更新 pos_MUL = [ 40, 445 - now_MUL *10] # MUL:0~15 # MUL の操作ポイントを、倍角 TOUCH（8x8）*2 で表示する LCD.fill_rect(pos_MUL[0] -TOUCH, pos_MUL[1] -TOUCH, TOUCH*2, TOUCH*2, LCD.PURPLE) # MUL 数値表示 文字領域を 白色にしてから表示 dspMUL(now_MUL) # edt_Ys 更新 edt_Ys = pos_MUL[1] elif edt_mode == 'DT': if in_zone(guide_DTs, guide_DTe, X_Point, Y_Point): # DT 編集ゾーンならば # print('edt_mode DT') if edt_Ys != Y_Point: # 操作感度を上げる場合は、/4 の数字を小さく、下げる場合は、/4 の数字を大きく # edt_def = int((Y_Point - edt_Ys) /4) edt_def = int((Y_Point - edt_Ys) /8) # 加減算の正負に注意（x軸は右方向に正、y軸は下方向に正） now_DT += (edt_def *sign_DT) # 範囲に収める処理 now_DT = 0 if now_DT < 0 else now_DT now_DT = max_DT if now_DT > max_DT else now_DT # 表示ポイント更新 計算方法は項目ごとに異なるので注意 # スライダーポイントの座標設定（Pixcel単位）：絶対値 pos_DT = [120, 445 - now_DT *10] # DT:0~7 # DT の操作ポイントを、倍角 TOUCH（8x8）*2 で表示する LCD.fill_rect(pos_DT[0] -TOUCH, pos_DT[1] -TOUCH, TOUCH*2, TOUCH*2, LCD.PURPLE) # DT 数値表示 文字領域を 白色にしてから表示 dspDT(now_DT) # edt_Ys 更新 edt_Ys = pos_DT[1] else: # get == None edt_mode = '' # カウンタのクリア cnt_MUL = 0 cnt_DT = 0 # FB カウンタのクリア for i in range(max_FB +1): cnt_FBi[i] = 0 # XOF カウンタのクリア for i in range(max_XOF +1): cnt_XOFi[i] = 0 # cnt_tabM cnt_tabS cntOP のクリア for i in range(5): cnt_tabM[i] = 0 cnt_tabS[i] = 0 cnt_OP[i] = 0 LCD.show() return(tabM_num, tabS_num, OP_num, now_MUL, now_DT, now_FB, now_XOF) # DAM EAM DVB EVB の編集 def edit_dam(tabM_num, tabS_num, OP_num, now_DAM, now_EAM, now_DVB, now_EVB): # Main Tab の座標リストを取得 zoneMtab_s = TAB.get_zoneMtab_s() zoneMtab_e = TAB.get_zoneMtab_e() # Sub Tab の座標リストを取得 zoneStab_s = TAB.get_zoneStab_s() zoneStab_e = TAB.get_zoneStab_e() # ALG op1 ~ op4 の座標リストを取得 zOPs = TAB.get_zOPs() zOPe = TAB.get_zOPe() # 上段表示エリアの開始座標と終末座標を取得 zUPs = TAB.get_zUPs() zUPe = TAB.get_zUPe() # 下段表示エリアの開始座標と終末座標を取得 zLWs = TAB.get_zLWs() zLWe = TAB.get_zLWe() # DAM タッチゾーンの設定 # DAM タッチ開始座標は、冒頭で設定したものを利用する zone_DAMsi = [None, None] *(max_DAM +1) zone_DAMei = [None, None] *(max_DAM +1) for i in range(max_DAM +1): zone_DAMsi[i] = [DAMxs[i], DAMys[i]] zone_DAMei[i] = [DAMxs[i]+16*6, DAMys[i]+20] # DAM カウンタの設定 cnt_DAMi = [None] *(max_DAM +1) for i in range(max_DAM +1): cnt_DAMi[i] = 0 # DVB タッチゾーンの設定 # DVB タッチ開始座標は、main で設定したものを利用する zone_DVBsi = [None, None] *(max_DVB +1) zone_DVBei = [None, None] *(max_DVB +1) for i in range(max_DVB +1): zone_DVBsi[i] = [DVBxs[i], DVBys[i]] zone_DVBei[i] = [DVBxs[i]+16*6, DVBys[i]+20] # DVB カウンタの設定 cnt_DVBi = [None] *(max_DVB +1) for i in range(max_DVB +1): cnt_DVBi[i] = 0 # EAM タッチゾーンの設定 # EAM タッチ開始座標は、main で設定したものを利用する zone_EAMsi = [None, None] *(max_EAM +1) zone_EAMei = [None, None] *(max_EAM +1) for i in range(max_EAM +1): zone_EAMsi[i] = [EAMxs[i], EAMys[i]] zone_EAMei[i] = [EAMxs[i]+16*6, EAMys[i]+20] # EAM カウンタの設定 cnt_EAMi = [None] *(max_EAM +1) for i in range(max_EAM +1): cnt_EAMi[i] = 0 # EVB タッチゾーンの設定 # EVB タッチ開始座標は、冒頭で設定したものを利用する zone_EVBsi = [None, None] *(max_EVB +1) zone_EVBei = [None, None] *(max_EVB +1) for i in range(max_EVB +1): zone_EVBsi[i] = [EVBxs[i], EVBys[i]] zone_EVBei[i] = [EVBxs[i]+16*6, EVBys[i]+20] # EVB カウンタの設定 cnt_EVBi = [None] *(max_EVB +1) for i in range(max_EVB +1): cnt_EVBi[i] = 0 # cnt_tabM cnt_tabS cntOP の初期化 cnt_tabM = [None] * 5 cnt_tabS = [None] * 5 cnt_OP = [None] * 5 for i in range(5): cnt_tabM[i] = 0 cnt_tabS[i] = 0 cnt_OP[i] = 0 # 終了条件の設定 tabM_num_old = tabM_num tabS_num_old = tabS_num OP_num_old = OP_num while tabM_num_old == tabM_num and tabS_num_old == tabS_num and OP_num_old == OP_num: # 設定内容を表示する dspFillLower(LCD.WHITE) # EAM の表示 LCD.text_scaled(f'EAM', 32+8+16, 455, LCD.BLACK, 2) # EAM 数値表示 文字領域を 緑色にしてから表示、文字色は一旦灰色 for eam in range(max_EAM +1): # EAM 設定内容の表示 dsp_EAM(eam, LCD.GREEN, LCD.GRAY) # EAM 設定値の表示 dsp_EAM(now_EAM, LCD.YELLOW, LCD.PURPLE) # DAM の表示 LCD.text_scaled(f'DAM', 32+8+16, 375, LCD.BLACK, 2) # DAM 数値表示 文字領域を 緑色にしてから表示、文字色は一旦灰色 for dam in range(max_DAM +1): # DAM 設定内容の表示 dsp_DAM(dam, LCD.GREEN, LCD.GRAY) # DAM 設定値の表示 dsp_DAM(now_DAM, LCD.YELLOW, LCD.PURPLE) # EVB の表示 LCD.text_scaled(f'EVB', 192+8+16, 455, LCD.BLACK, 2) # EVB 数値表示 文字領域を 緑色にしてから表示、文字色は一旦灰色 for evb in range(max_EVB +1): # EVB 設定内容の表示 dsp_EVB(evb, LCD.GREEN, LCD.GRAY) # EVB 設定値の表示 dsp_EVB(now_EVB, LCD.YELLOW, LCD.PURPLE) # DVB の表示 LCD.text_scaled(f'DVB',192+8+16, 375, LCD.BLACK, 2) # DVB 数値表示 文字領域を 緑色にしてから表示、文字色は一旦灰色 for dvb in range(max_DVB +1): # DVB 設定内容の表示 dsp_DVB(dvb, LCD.GREEN, LCD.GRAY) # DVB 設定値の表示 dsp_DVB(now_DVB, LCD.YELLOW, LCD.PURPLE) get = LCD.touch_get() if get != None: # タッチされているなら X_Point = get[0] Y_Point = get[1] for i in range(max_DAM +1): if in_zone(zone_DAMsi[i], zone_DAMei[i], X_Point, Y_Point): # print(f'zone_DAM{i}') cnt_DAMi[i] += 1 if cnt_DAMi[i] == TOUCH_TH: # 差分検出用に現在値を記録（Pixcel値） edt_Xs = X_Point edt_Ys = Y_Point now_DAM = i # DAM 数値表示 背景を黄色にし、文字色は紫色 dsp_DAM(now_DAM, LCD.YELLOW, LCD.PURPLE) edt_mode = f'DAM{i}' print(f'select_DAM{i}') for i in range(max_DVB +1): if in_zone(zone_DVBsi[i], zone_DVBei[i], X_Point, Y_Point): # print(f'zone_DVB{i}') cnt_DVBi[i] += 1 if cnt_DVBi[i] == TOUCH_TH: # 差分検出用に現在値を記録（Pixcel値） edt_Xs = X_Point edt_Ys = Y_Point now_DVB = i # DVB 数値表示 背景を黄色にし、文字色は紫色 dsp_DVB(now_DVB, LCD.YELLOW, LCD.PURPLE) edt_mode = f'DVB{i}' print(f'select_DVB{i}') for i in range(max_EAM +1): if in_zone(zone_EAMsi[i], zone_EAMei[i], X_Point, Y_Point): # print(f'zone_EAM{i}') cnt_EAMi[i] += 1 if cnt_EAMi[i] == TOUCH_TH: # 差分検出用に現在値を記録（Pixcel値） edt_Xs = X_Point edt_Ys = Y_Point now_EAM = i # EAM 数値表示 背景を黄色にし、文字色は紫色 dsp_EAM(now_EAM, LCD.YELLOW, LCD.PURPLE) edt_mode = f'EAM{i}' print(f'select_EAM{i}') for i in range(max_EVB +1): if in_zone(zone_EVBsi[i], zone_EVBei[i], X_Point, Y_Point): # print(f'zone_EVB{i}') cnt_EVBi[i] += 1 if cnt_EVBi[i] == TOUCH_TH: # 差分検出用に現在値を記録（Pixcel値） edt_Xs = X_Point edt_Ys = Y_Point now_EVB = i # EVB 数値表示 背景を黄色にし、文字色は紫色 dsp_EVB(now_EVB, LCD.YELLOW, LCD.PURPLE) edt_mode = f'EVB{i}' print(f'select_EVB{i}') # mainTab のタッチで終了 if in_zone(zoneMtab_s[1], zoneMtab_e[4], X_Point, Y_Point): for i in range(1, 5): if in_zone(zoneMtab_s[i], zoneMtab_e[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば # print(f'select zoneMtab[{i}]') cnt_tabM[i] += 1 if cnt_tabM[i] == TOUCH_TH: tabM_num = i print(f'main-menu Select = {tabM_num}') # subTab のタッチで終了 if in_zone(zoneStab_s[1], zoneStab_e[4], X_Point, Y_Point): for i in range(1, 5): if in_zone(zoneStab_s[i], zoneStab_e[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば # print(f'select zoneStab[{i}]') cnt_tabS[i] += 1 if cnt_tabS[i] == TOUCH_TH: tabS_num = i print(f'sub-menu Select = {tabS_num}') # OP のタッチで終了 # 上段表示エリアか？ if in_zone(zUPs, zUPe, X_Point, Y_Point): for i in range(1, 5): if in_zone(zOPs[i], zOPe[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば # print(f'select zOP[{i}]') cnt_OP[i] += 1 if cnt_OP[i] == TOUCH_TH: OP_num = i print(f'ALG OP Select = {OP_num}') else: # get == None # カウンタクリア for i in range(max_DAM +1): cnt_DAMi[i] = 0 for i in range(max_DVB +1): cnt_DVBi[i] = 0 for i in range(max_EAM +1): cnt_EAMi[i] = 0 for i in range(max_EVB +1): cnt_EVBi[i] = 0 for i in range(5): cnt_tabM[i] = 0 cnt_tabS[i] = 0 cnt_OP[i] = 0 LCD.show() return(tabM_num, tabS_num, OP_num, now_DAM, now_EAM, now_DVB, now_EVB) # BO LFO の編集 def edit_bo(tabM_num, tabS_num, OP_num, now_BO, now_LFO, tone_num, tone_name): # Main Tab の座標リストを取得 zoneMtab_s = TAB.get_zoneMtab_s() zoneMtab_e = TAB.get_zoneMtab_e() # Sub Tab の座標リストを取得 zoneStab_s = TAB.get_zoneStab_s() zoneStab_e = TAB.get_zoneStab_e() # ALG op1 ~ op4 の座標リストを取得 zOPs = TAB.get_zOPs() zOPe = TAB.get_zOPe() # 上段表示エリアの開始座標と終末座標を取得 zUPs = TAB.get_zUPs() zUPe = TAB.get_zUPe() # 下段表示エリアの開始座標と終末座標を取得 zLWs = TAB.get_zLWs() zLWe = TAB.get_zLWe() # BO タッチゾーンの設定 # BO タッチ開始座標は、冒頭で設定したものを利用する zone_BOsi = [None, None] *(max_BO +1) zone_BOei = [None, None] *(max_BO +1) for i in range(max_BO +1): zone_BOsi[i] = [BOxs[i], BOys[i]] zone_BOei[i] = [BOxs[i]+16*5, BOys[i]+20] # BO カウンタの設定 cnt_BOi = [None] *(max_BO +1) for i in range(max_BO +1): cnt_BOi[i] = 0 # LFO タッチゾーンの設定 # LFO タッチ開始座標は、main で設定したものを利用する zone_LFOsi = [None, None] *(max_LFO +1) zone_LFOei = [None, None] *(max_LFO +1) for i in range(max_LFO +1): zone_LFOsi[i] = [LFOxs[i], LFOys[i]] zone_LFOei[i] = [LFOxs[i]+16*5, LFOys[i]+20] # カウンタの設定 cnt_LFOi = [None] *(max_LFO +1) for i in range(max_LFO +1): cnt_LFOi[i] = 0 # cnt_tabM cnt_tabS cntOP の初期化 cnt_tabM = [None] * 5 cnt_tabS = [None] * 5 cnt_OP = [None] * 5 for i in range(5): cnt_tabM[i] = 0 cnt_tabS[i] = 0 cnt_OP[i] = 0 # 終了条件の設定 tabM_num_old = tabM_num tabS_num_old = tabS_num OP_num_old = OP_num while tabM_num_old == tabM_num and tabS_num_old == tabS_num and OP_num_old == OP_num: get = LCD.touch_get() if get != None: # タッチされているなら X_Point = get[0] Y_Point = get[1] for i in range(max_BO +1): if in_zone(zone_BOsi[i], zone_BOei[i], X_Point, Y_Point): print(f'zone_BO{i}') cnt_BOi[i] += 1 if cnt_BOi[i] >= TOUCH_TH: # 差分検出用に現在値を記録（Pixcel値） edt_Xs = X_Point edt_Ys = Y_Point now_BO = i # BO 数値表示 背景を黄色にし、文字色は紫色 dsp_BO(now_BO, LCD.YELLOW, LCD.PURPLE) edt_mode = f'BO{i}' cnt_BOi[i] = 0 for i in range(max_LFO +1): if in_zone(zone_LFOsi[i], zone_LFOei[i], X_Point, Y_Point): print(f'zone_LFO{i}') cnt_LFOi[i] += 1 if cnt_LFOi[i] >= TOUCH_TH: # 差分検出用に現在値を記録（Pixcel値） edt_Xs = X_Point edt_Ys = Y_Point now_LFO = i # LFO 数値表示 背景を黄色にし、文字色は紫色 dsp_LFO(now_LFO, LCD.YELLOW, LCD.PURPLE) edt_mode = f'LFO{i}' cnt_LFOi[i] = 0 # mainTab のタッチで終了 if in_zone(zoneMtab_s[1], zoneMtab_e[4], X_Point, Y_Point): for i in range(1, 5): if in_zone(zoneMtab_s[i], zoneMtab_e[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば print(f'select zoneMtab[{i}]') cnt_tabM[i] += 1 if cnt_tabM[i] >= TOUCH_TH: tabM_num = i print(f'main-menu Select = {tabM_num}') # subTab のタッチで終了 if in_zone(zoneStab_s[1], zoneStab_e[4], X_Point, Y_Point): for i in range(1, 5): if in_zone(zoneStab_s[i], zoneStab_e[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば print(f'select zoneStab[{i}]') cnt_tabS[i] += 1 if cnt_tabS[i] >= TOUCH_TH: tabS_num = i print(f'sub-menu Select = {tabS_num}') # OP のタッチで終了 # 上段表示エリアか？ if in_zone(zUPs, zUPe, X_Point, Y_Point): for i in range(1, 5): if in_zone(zOPs[i], zOPe[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば print(f'select zOP[{i}]') cnt_OP[i] += 1 if cnt_OP[i] >= TOUCH_TH: OP_num = i print(f'ALG OP Select = {OP_num}') else: # get == None # タッチされていないなら、設定内容を表示する dspFillUpper(LCD.WHITE) dspFillLower(LCD.WHITE) # ToneNumber ToneNmae を上段の末尾に表示する text = f'{tone_num:2}:{tone_name}' chr_num = len(text) zs = [10, 220] # dsp_text_bar(text, zs, chr_num, color_back, color_text) dsp_text_bar(text, zs, chr_num, LCD.WHITE, LCD.RED) # BO の表示 # LCD.text_scaled(f'BO', 32+8+16, 215, LCD.BLACK, 2) LCD.text_scaled(f'BO', 32+8+16, 240+215, LCD.BLACK, 2) # BO 数値表示 文字領域を 緑色にしてから表示、文字色は一旦灰色 for bo in range(max_BO +1): # BO 設定内容の表示 dsp_BO(bo, LCD.GREEN, LCD.GRAY) # BO 設定値の表示 dsp_BO(now_BO, LCD.YELLOW, LCD.PURPLE) # LFO の表示 # LCD.text_scaled(f'LFO',192+8+16, 215, LCD.BLACK, 2) LCD.text_scaled(f'LFO',192+8+16, 240+215, LCD.BLACK, 2) # LFO 数値表示 文字領域を 緑色にしてから表示、文字色は一旦灰色 for lfo in range(max_LFO +1): # LFO 設定内容の表示 dsp_LFO(lfo, LCD.GREEN, LCD.GRAY) # LFO 設定値の表示 dsp_LFO(now_LFO, LCD.YELLOW, LCD.PURPLE) LCD.show() return(tabM_num, tabS_num, OP_num, now_BO, now_LFO) # Tone Number の選択 # 20251018 def edit_ToneNumber(guide_msg, now_TN): を改名 # def select_ToneNumber(guide_msg, now_TN): def select_ToneNumber(tabM_num, tabS_num, guide_msg1, guide_msg2, now_TN, toneNameL): # 上段に ガイダンスを表示 dspFillUpper(LCD.WHITE) # WindowFrame 表示 zs = [0, 50] width = 320 height = 160 # = 末尾のzs(160) - zs(50) +10(１行目余白) +30（末尾の枠＋余白） color_line = LCD.RED color_back = LCD.YELLOW dsp_WindowFrame(zs, width, height, color_line, color_back) zs = [20, 70] text = guide_msg1 color_text = LCD.RED LCD.text_scaled(text,zs[0], zs[1], color_text, 2) zs = [20, 100] # text = 'Select Tone Number' text = guide_msg2 color_text = LCD.BLACK LCD.text_scaled(text,zs[0], zs[1], color_text, 2) zs = [20, 120] text = 'and Exec or Cancel' color_text = LCD.BLACK LCD.text_scaled(text,zs[0], zs[1], color_text, 2) # Cancel ボタンの開始座標と終末座標 text = 'Cancel' chr_num = len(text) zCANs = [30, 170] zCANe = [zCANs[0] + chr_num *chr_w, zCANs[1] + txt_h] # TAB.save_BtnCancel(zCANs, zCANe) color_line = LCD.BLACK color_back = LCD.BLUE color_text = LCD.GRAY dsp_text_frame(text, zCANs, chr_num, color_line, color_back, color_text) # Execute ボタンの開始座標と終末座標 text = 'Execute' chr_num = len(text) zEXEs = [170, 170] zEXEe = [zEXEs[0] + chr_num *chr_w, zEXEs[1] + txt_h] # TAB.save_BtnExec(zEXEs, zEXEe) color_line = LCD.BLACK color_back = LCD.BLUE color_text = LCD.GRAY dsp_text_frame(text, zEXEs, chr_num, color_line, color_back, color_text) # LCD.show() # Main Tab の座標リストを取得 zoneMtab_s = TAB.get_zoneMtab_s() zoneMtab_e = TAB.get_zoneMtab_e() # Sub Tab の座標リストを取得 zoneStab_s = TAB.get_zoneStab_s() zoneStab_e = TAB.get_zoneStab_e() # cnt_tabM cnt_tabS cntOP の初期化 cnt_tabM = [None] * 5 cnt_tabS = [None] * 5 for i in range(5): cnt_tabM[i] = 0 cnt_tabS[i] = 0 # TN タッチゾーンの設定 # TN タッチ開始座標は、このプログラムの冒頭で設定したものを利用する zone_TNsi = [None, None] *16 zone_TNei = [None, None] *16 for i in range(max_TN +1): zone_TNsi[i] = [TNxs[i], TNys[i]] zone_TNei[i] = [TNxs[i]+16*3, TNys[i]+30] # カウンタの設定 cnt_TNi = [None] *(max_TN +1) for i in range(max_TN +1): cnt_TNi[i] = 0 cnt_Exe = 0 cnt_Can = 0 # 終了条件の設定 tabM_num_old = tabM_num tabS_num_old = tabS_num btn = '' # Cancel または Execute ボタンが押されたら終了 # while not(btn == 'Cancel' or btn == 'Execute'): while tabM_num_old == tabM_num and tabS_num_old == tabS_num \ and not(btn == 'Cancel' or btn == 'Execute'): dspFillLower(LCD.WHITE) zs = [20, 270] # text = 'Select Tone Number' text = guide_msg1 color_text = LCD.BLACK LCD.text_scaled(text, zs[0], zs[1], color_text, 2) # TN 数値表示 文字領域を 緑色にしてから表示、文字色は一旦灰色 for tn in range(max_TN +1): # TN 設定内容の表示 dsp_TN(tn, LCD.GREEN, LCD.GRAY) # TN 設定値のハイライト表示 dsp_TN(now_TN, LCD.YELLOW, LCD.PURPLE) # Tone Name を表示する text = toneNameL[now_TN] chr_num = 16 zs = [60, 440] dsp_text_bar(text, zs, chr_num, LCD.WHITE, LCD.RED) get = LCD.touch_get() if get != None: # タッチされているなら X_Point = get[0] Y_Point = get[1] for i in range(max_TN +1): if in_zone(zone_TNsi[i], zone_TNei[i], X_Point, Y_Point): # print(f'zone_TN{i}') cnt_TNi[i] += 1 if cnt_TNi[i] == TOUCH_TH: print(f'select_TN{i}') # 差分検出用に現在値を記録（Pixcel値） edt_Xs = X_Point edt_Ys = Y_Point now_TN = i # TN 数値表示 背景を黄色にし、文字色は紫色 dsp_TN(now_TN, LCD.YELLOW, LCD.PURPLE) # Execute ボタンが押されたら終了 if in_zone(zEXEs, zEXEe, X_Point, Y_Point): # print(f'Execute Button') cnt_Exe += 1 if cnt_Exe == TOUCH_TH: print(f'Execute Button') btn = 'Execute' # 選択されたボタンの色を変える text = 'Execute' chr_num = len(text) color_line = LCD.BLACK color_back = LCD.GREEN color_text = LCD.RED dsp_text_frame(text, zEXEs, chr_num, color_line, color_back, color_text) # LCD.show() # Cancel ボタンが押されたら終了 elif in_zone(zCANs, zCANe, X_Point, Y_Point): # print('Cancel Button') cnt_Can += 1 if cnt_Can == TOUCH_TH: print('Cancel Button') btn = 'Cancel' # 選択されたボタンの色を変える text = 'Cancel' chr_num = len(text) color_line = LCD.BLACK color_back = LCD.GREEN color_text = LCD.RED dsp_text_frame(text, zCANs, chr_num, color_line, color_back, color_text) # LCD.show() # mainTab のタッチで終了 elif in_zone(zoneMtab_s[1], zoneMtab_e[4], X_Point, Y_Point): for i in range(1, 5): if in_zone(zoneMtab_s[i], zoneMtab_e[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば # print(f'zoneMtab[{i}]') cnt_tabM[i] += 1 if cnt_tabM[i] == TOUCH_TH: tabM_num = i print(f'main-menu Select = {tabM_num}') # subTab のタッチで終了 elif in_zone(zoneStab_s[1], zoneStab_e[4], X_Point, Y_Point): for i in range(1, 5): if in_zone(zoneStab_s[i], zoneStab_e[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば # print(f'zoneStab[{i}]') cnt_tabS[i] += 1 if cnt_tabS[i] == TOUCH_TH: tabS_num = i print(f'sub-menu Select = {tabS_num}') else: # get == None # カウンタをクリア for i in range(5): cnt_tabM[i] = 0 cnt_tabS[i] = 0 for i in range(max_TN +1): cnt_TNi[i] = 0 cnt_Exe = 0 cnt_Can = 0 LCD.show() return (tabM_num, tabS_num, btn, now_TN) # Swapping Channel の選択 def select_SwapCh(tabM_num, tabS_num, guide_msg1, guide_msg2, ch): # 上段に ガイダンスを表示 dspFillUpper(LCD.WHITE) # WindowFrame 表示 zs = [0, 50] width = 320 height = 160 # = 末尾のzs(160) - zs(50) +10(１行目余白) +30（末尾の枠＋余白） color_line = LCD.RED color_back = LCD.YELLOW dsp_WindowFrame(zs, width, height, color_line, color_back) zs = [20, 70] text = guide_msg1 color_text = LCD.RED LCD.text_scaled(text,zs[0], zs[1], color_text, 2) zs = [20, 100] # text = 'Select Tone Number' text = guide_msg2 color_text = LCD.BLACK LCD.text_scaled(text,zs[0], zs[1], color_text, 2) zs = [20, 120] text = 'and Exec or Cancel' color_text = LCD.BLACK LCD.text_scaled(text,zs[0], zs[1], color_text, 2) # Cancel ボタンの開始座標と終末座標 text = 'Cancel' chr_num = len(text) zCANs = [30, 170] zCANe = [zCANs[0] + chr_num *chr_w, zCANs[1] + txt_h] # TAB.save_BtnCancel(zCANs, zCANe) color_line = LCD.BLACK color_back = LCD.BLUE color_text = LCD.GRAY dsp_text_frame(text, zCANs, chr_num, color_line, color_back, color_text) # Execute ボタンの開始座標と終末座標 text = 'Execute' chr_num = len(text) zEXEs = [170, 170] zEXEe = [zEXEs[0] + chr_num *chr_w, zEXEs[1] + txt_h] # TAB.save_BtnExec(zEXEs, zEXEe) color_line = LCD.BLACK color_back = LCD.BLUE color_text = LCD.GRAY dsp_text_frame(text, zEXEs, chr_num, color_line, color_back, color_text) # Main Tab の座標リストを取得 zoneMtab_s = TAB.get_zoneMtab_s() zoneMtab_e = TAB.get_zoneMtab_e() # Sub Tab の座標リストを取得 zoneStab_s = TAB.get_zoneStab_s() zoneStab_e = TAB.get_zoneStab_e() # cnt_tabM cnt_tabS cntOP の初期化 cnt_tabM = [None] * 5 cnt_tabS = [None] * 5 for i in range(5): cnt_tabM[i] = 0 cnt_tabS[i] = 0 # TN タッチゾーンの設定 # TN タッチ開始座標は、このプログラムの冒頭で設定したものを利用する zone_TNsi = [None, None] *16 zone_TNei = [None, None] *16 for i in range(max_TN +1): zone_TNsi[i] = [TNxs[i], TNys[i]] zone_TNei[i] = [TNxs[i]+16*3, TNys[i]+30] # カウンタの設定 cnt_TNi = [None] *(max_TN +1) for i in range(max_TN +1): cnt_TNi[i] = 0 cnt_Exe = 0 cnt_Can = 0 # 終了条件の設定 tabM_num_old = tabM_num tabS_num_old = tabS_num btn = '' # Cancel または Execute ボタンが押されたら終了 # while not(btn == 'Cancel' or btn == 'Execute'): while tabM_num_old == tabM_num and tabS_num_old == tabS_num \ and not(btn == 'Cancel' or btn == 'Execute'): dspFillLower(LCD.WHITE) zs = [20, 270] # text = 'Select Tone Number' text = guide_msg1 color_text = LCD.BLACK LCD.text_scaled(text, zs[0], zs[1], color_text, 2) # TN 数値表示 文字領域を 緑色にしてから表示、文字色は一旦灰色 for tn in range(max_TN +1): # TN 設定内容の表示 dsp_TN(tn, LCD.GREEN, LCD.GRAY) # TN 設定値のハイライト表示 dsp_TN(ch, LCD.YELLOW, LCD.PURPLE) get = LCD.touch_get() if get != None: # タッチされているなら X_Point = get[0] Y_Point = get[1] for i in range(max_TN +1): if in_zone(zone_TNsi[i], zone_TNei[i], X_Point, Y_Point): # print(f'zone_TN{i}') cnt_TNi[i] += 1 if cnt_TNi[i] == TOUCH_TH: print(f'select_TN{i}') # 差分検出用に現在値を記録（Pixcel値） edt_Xs = X_Point edt_Ys = Y_Point ch = i # TN 数値表示 背景を黄色にし、文字色は紫色 dsp_TN(ch, LCD.YELLOW, LCD.PURPLE) # Execute ボタンが押されたら終了 if in_zone(zEXEs, zEXEe, X_Point, Y_Point): # print(f'Execute Button') cnt_Exe += 1 if cnt_Exe == TOUCH_TH: print(f'Execute Button') btn = 'Execute' # 選択されたボタンの色を変える text = 'Execute' chr_num = len(text) color_line = LCD.BLACK color_back = LCD.GREEN color_text = LCD.RED dsp_text_frame(text, zEXEs, chr_num, color_line, color_back, color_text) # LCD.show() # Cancel ボタンが押されたら終了 elif in_zone(zCANs, zCANe, X_Point, Y_Point): # print('Cancel Button') cnt_Can += 1 if cnt_Can == TOUCH_TH: print('Cancel Button') btn = 'Cancel' # 選択されたボタンの色を変える text = 'Cancel' chr_num = len(text) color_line = LCD.BLACK color_back = LCD.GREEN color_text = LCD.RED dsp_text_frame(text, zCANs, chr_num, color_line, color_back, color_text) # LCD.show() # mainTab のタッチで終了 elif in_zone(zoneMtab_s[1], zoneMtab_e[4], X_Point, Y_Point): for i in range(1, 5): if in_zone(zoneMtab_s[i], zoneMtab_e[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば # print(f'zoneMtab[{i}]') cnt_tabM[i] += 1 if cnt_tabM[i] == TOUCH_TH: tabM_num = i print(f'main-menu Select = {tabM_num}') # subTab のタッチで終了 elif in_zone(zoneStab_s[1], zoneStab_e[4], X_Point, Y_Point): for i in range(1, 5): if in_zone(zoneStab_s[i], zoneStab_e[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば # print(f'zoneStab[{i}]') cnt_tabS[i] += 1 if cnt_tabS[i] == TOUCH_TH: tabS_num = i print(f'sub-menu Select = {tabS_num}') else: # get == None # カウンタをクリア for i in range(5): cnt_tabM[i] = 0 cnt_tabS[i] = 0 for i in range(max_TN +1): cnt_TNi[i] = 0 cnt_Exe = 0 cnt_Can = 0 LCD.show() return (tabM_num, tabS_num, btn, ch) # title, guide1, guide2 を表示して、実行するか否かを選択する def select_CanExe(title, guide1, guide2): # 上段に ガイダンスを表示 dspFillUpper(LCD.WHITE) # WindowFrame 表示 zs = [0, 50] width = 320 height = 160 # = 末尾のzs(160) - zs(50) +10(１行目余白) +30（末尾の枠＋余白） color_line = LCD.RED color_back = LCD.YELLOW dsp_WindowFrame(zs, width, height, color_line, color_back) zs = [20, 70] text = title color_text = LCD.RED LCD.text_scaled(text,zs[0], zs[1], color_text, 2) zs = [20, 100] text = guide1 color_text = LCD.BLACK LCD.text_scaled(text,zs[0], zs[1], color_text, 2) zs = [20, 120] text = guide2 color_text = LCD.BLACK LCD.text_scaled(text,zs[0], zs[1], color_text, 2) # Cancel ボタンの開始座標と終末座標 text = 'Cancel' chr_num = len(text) zCANs = [30, 170] zCANe = [zCANs[0] + chr_num *chr_w, zCANs[1] + txt_h] # TAB.save_BtnCancel(zCANs, zCANe) color_line = LCD.BLACK color_back = LCD.BLUE color_text = LCD.GRAY dsp_text_frame(text, zCANs, chr_num, color_line, color_back, color_text) # Execute ボタンの開始座標と終末座標を保存 text = 'Execute' chr_num = len(text) zEXEs = [170, 170] zEXEe = [zEXEs[0] + chr_num *chr_w, zEXEs[1] + txt_h] # TAB.save_BtnExec(zEXEs, zEXEe) color_line = LCD.BLACK color_back = LCD.BLUE color_text = LCD.GRAY dsp_text_frame(text, zEXEs, chr_num, color_line, color_back, color_text) LCD.show() # 終了条件の設定 btn = '' # Cancel または Execute ボタンが押されたら終了 while not(btn == 'Cancel' or btn == 'Execute'): get = LCD.touch_get() if get != None: # タッチされているなら X_Point = get[0] Y_Point = get[1] # Execute ボタンが押されたら終了 if in_zone(zEXEs, zEXEe, X_Point, Y_Point): print(f'Execute Button') cnt_Exe += 1 if cnt_Exe >= TOUCH_TH: btn = 'Execute' # 選択されたボタンの色を変える text = 'Execute' chr_num = len(text) color_line = LCD.BLACK color_back = LCD.GREEN color_text = LCD.RED dsp_text_frame(text, zEXEs, chr_num, color_line, color_back, color_text) LCD.show() # Cancel ボタンが押されたら終了 if in_zone(zCANs, zCANe, X_Point, Y_Point): print('Cancel Button') cnt_Can += 1 if cnt_Can >= TOUCH_TH: btn = 'Cancel' # 選択されたボタンの色を変える text = 'Cancel' chr_num = len(text) color_line = LCD.BLACK color_back = LCD.GREEN color_text = LCD.RED dsp_text_frame(text, zCANs, chr_num, color_line, color_back, color_text) LCD.show() else: # get == None cnt_Exe = 0 cnt_Can = 0 # LCD.show() return btn # file_list から １つの File を選択 # def select_File(file_list, guide1, guide2, list_name): def select_Item(tabM_num, tabS_num, file_list, guide1, guide2, list_name): list_size = len(file_list) page_size = 7 # LCD 表示行数 page_max, point_mod = divmod(list_size, page_size) page_now = 0 # FileName 表示とタッチ開始座標と終末座標 zNAMEs = [ 10, 290] zNAMEe = [310, 310] # FileName 複数のタッチゾーンの設定 zNAMEsi = [None, None] *page_size zNAMEei = [None, None] *page_size for i in range(page_size): zNAMEsi[i] = [zNAMEs[0], zNAMEs[1] +txt_h *i] zNAMEei[i] = [zNAMEe[0], zNAMEe[1] +txt_h *i] # 上段に ガイダンスを表示 dspFillUpper(LCD.WHITE) # WindowFrame 表示 zs = [0, 50] width = 320 height = 160 # = 末尾のzs(160) - zs(50) +10(１行目余白) +30（末尾の枠＋余白） color_line = LCD.RED color_back = LCD.YELLOW dsp_WindowFrame(zs, width, height, color_line, color_back) zs = [20, 70] # text = 'Get Tone Data' # color_text = LCD.RED LCD.text_scaled(guide1, zs[0], zs[1], LCD.RED, 2) zs = [20, 100] # text = 'Select File Name' # color_text = LCD.BLACK LCD.text_scaled(guide2, zs[0], zs[1], LCD.BLACK, 2) zs = [20, 120] text = 'and OK or Cancel' color_text = LCD.BLACK LCD.text_scaled(text,zs[0], zs[1], color_text, 2) # Cancel ボタンの表示とタッチゾーンの設定 text = 'Cancel' chr_num = len(text) zCANs = [30, 170] zCANe = [zCANs[0] + chr_num *chr_w, zCANs[1] + txt_h] # TAB.save_BtnCancel(zCANs, zCANe) color_line = LCD.BLACK color_back = LCD.BLUE color_text = LCD.GRAY dsp_text_frame(text, zCANs, chr_num, color_line, color_back, color_text) # Execute ボタンの開始座標と終末座標を保存 text = ' OK ' chr_num = len(text) zEXEs = [170, 170] zEXEe = [zEXEs[0] + chr_num *chr_w, zEXEs[1] + txt_h] # TAB.save_BtnExec(zEXEs, zEXEe) color_line = LCD.BLACK color_back = LCD.BLUE color_text = LCD.GRAY dsp_text_frame(text, zEXEs, chr_num, color_line, color_back, color_text) # Main Tab の座標リストを取得 zoneMtab_s = TAB.get_zoneMtab_s() zoneMtab_e = TAB.get_zoneMtab_e() # Sub Tab の座標リストを取得 zoneStab_s = TAB.get_zoneStab_s() zoneStab_e = TAB.get_zoneStab_e() # cnt_tabM cnt_tabS cntOP の初期化 cnt_tabM = [None] * 5 cnt_tabS = [None] * 5 for i in range(5): cnt_tabM[i] = 0 cnt_tabS[i] = 0 # カウンタの設定 cnt_NAMEi = [None] *(page_size) for i in range(page_size): cnt_NAMEi[i] = 0 cnt_Exe = 0 cnt_Can = 0 cnt_PgUp = 0 cnt_PgDw = 0 # 終了条件の設定 file_name = '' file_select = 0 # 終了条件の設定 tabM_num_old = tabM_num tabS_num_old = tabS_num btn = '' # Cancel または Execute（表示は [OK] ボタンが押されたら終了 # while not(btn == 'Cancel' or btn == 'Execute'): while tabM_num_old == tabM_num and tabS_num_old == tabS_num \ and not(btn == 'Cancel' or btn == 'Execute'): # 下段に ガイダンスを表示 dspFillLower(LCD.WHITE) zs = [10,270] # text = 'File Name' # dsp_text_bar(text, zs, chr_num, color_back, color_text) dsp_text_bar(list_name, zs, 18, LCD.YELLOW, LCD.BLUE) # 0 =< page_now <= page_max に制限する page_now = page_now if page_now <= page_max else page_max page_now = 0 if page_now < 0 else page_now # file_list へのアクセスポイントと表示 point_now = page_now *page_size # 0, 7, 14, 21, 28, 35, 42 # 0-6 ずつ表示する最後の行 = point_end 差分値 if page_now < page_max: point_end = page_size else: point_end = point_mod # file name 表示 for i in range(point_end): # dsp_text_bar(text, zs, chr_num, color_back, color_text) dsp_text_bar(file_list[point_now +i], zNAMEsi[i], 18, LCD.GREEN, LCD.BLACK) # file_select あれば if file_select == 1 and select_page == page_now: file_name = file_list[point_now +file_point] # dsp_text_bar(text, zs, chr_num, color_back, color_text) dsp_text_bar(file_name, zNAMEsi[file_point], 18, LCD.YELLOW, LCD.RED) # 現在ページと終末ページ text = f'{page_now +1: 2}/{page_max +1: 2}' # [ 9/99] chr_num = 5 zs = [24, 445] # dsp_text_frame(text, zs, chr_num, color_line, color_back, color_text) dsp_text_frame(text, zs, chr_num, LCD.BLACK, LCD.WHITE, LCD.BLACK) # Page Up ボタンの表示とゾーン設定 text = 'PgUp' chr_num = len(text) zUPs = [136, 445] zUPe = [zUPs[0] + chr_num *chr_w, zUPs[1] + txt_h] # dsp_text_frame(text, zs, chr_num, color_line, color_back, color_text) dsp_text_frame(text, zUPs, chr_num, LCD.BLACK, LCD.BLUE, LCD.YELLOW) # Page Down ボタンの表示とゾーン設定 text = 'PgDw' chr_num = len(text) zDWs = [232, 445] zDWe = [zDWs[0] + chr_num *chr_w, zDWs[1] + txt_h] # dsp_text_frame(text, zs, chr_num, color_line, color_back, color_text) dsp_text_frame(text, zDWs, chr_num, LCD.BLACK, LCD.BLUE, LCD.YELLOW) get = LCD.touch_get() if get != None: # タッチされているなら X_Point = get[0] Y_Point = get[1] zNAMEsi for i in range(point_end): if in_zone(zNAMEsi[i], zNAMEei[i], X_Point, Y_Point): # print(f'zNAME = {file_list[i]}') cnt_NAMEi[i] += 1 if cnt_NAMEi[i] == TOUCH_TH: # 差分検出用に現在値を記録（Pixcel値） edt_Xs = X_Point edt_Ys = Y_Point file_select = 1 select_page = page_now file_point = i file_name = file_list[point_now +file_point] print(f'Select File Name = {file_name}') # NAME 表示 背景を黄色にし、文字色は紫色 dsp_text_bar(file_name, zNAMEsi[i], 18, LCD.YELLOW, LCD.PURPLE) # PageUP ボタンが押されたら if in_zone(zUPs, zUPe, X_Point, Y_Point): cnt_PgUp += 1 if cnt_PgUp >= TOUCH_TH: # １回だけカウントする if cnt_PgUp == TOUCH_TH: print(f'PageUP Button') page_now -= 1 # 選択されたボタンの色を変える text = 'PgUp' chr_num = len(text) dsp_text_frame(text, zUPs, chr_num, LCD.BLACK, LCD.YELLOW, LCD.PURPLE) # PageDown ボタンが押されたら elif in_zone(zDWs, zDWe, X_Point, Y_Point): cnt_PgDw += 1 if cnt_PgDw >= TOUCH_TH: # １回だけカウントする if cnt_PgDw == TOUCH_TH: print(f'PageDown Button') page_now += 1 # 選択されたボタンの色を変える text = 'PgDw' chr_num = len(text) dsp_text_frame(text, zDWs, chr_num, LCD.BLACK, LCD.YELLOW, LCD.PURPLE) # Execute ボタンが押されたら終了 elif in_zone(zEXEs, zEXEe, X_Point, Y_Point): cnt_Exe += 1 if cnt_Exe == TOUCH_TH: print(f'Execute Button') btn = 'Execute' # 選択されたボタンの色を変える # text = 'Execute' text = ' OK ' chr_num = len(text) dsp_text_frame(text, zEXEs, chr_num, LCD.BLACK, LCD.GREEN, LCD.RED) # 表示して while の外へ # Cancel ボタンが押されたら終了 elif in_zone(zCANs, zCANe, X_Point, Y_Point): cnt_Can += 1 if cnt_Can == TOUCH_TH: print('Cancel Button') btn = 'Cancel' # 選択されたボタンの色を変える text = 'Cancel' chr_num = len(text) dsp_text_frame(text, zCANs, chr_num, LCD.BLACK, LCD.GREEN, LCD.RED) # 表示して while の外へ # mainTab のタッチで終了 elif in_zone(zoneMtab_s[1], zoneMtab_e[4], X_Point, Y_Point): for i in range(1, 5): if in_zone(zoneMtab_s[i], zoneMtab_e[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば print(f'select zoneMtab[{i}]') cnt_tabM[i] += 1 if cnt_tabM[i] >= TOUCH_TH: tabM_num = i print(f'main-menu Select = {tabM_num}') # subTab のタッチで終了 elif in_zone(zoneStab_s[1], zoneStab_e[4], X_Point, Y_Point): for i in range(1, 5): if in_zone(zoneStab_s[i], zoneStab_e[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば print(f'select zoneStab[{i}]') cnt_tabS[i] += 1 if cnt_tabS[i] >= TOUCH_TH: tabS_num = i print(f'sub-menu Select = {tabS_num}') else: # get == None # カウンタのクリア # cnt_tabM cnt_tabS cntOP の初期化 for i in range(5): cnt_tabM[i] = 0 cnt_tabS[i] = 0 # cnt_NAMEi = [None] *(page_size) for i in range(page_size): cnt_NAMEi[i] = 0 cnt_Exe = 0 cnt_Can = 0 cnt_PgUp = 0 cnt_PgDw = 0 LCD.show() # return btn, file_name return (tabM_num, tabS_num, btn, file_name) # Full Key による Text の編集 # Text の開始座標（余白＝背景を含む）から、chr_num で指定された桁数の編集を行う def edit_text(text, chr_num, zs, color_back, color_text): blink = 0 # 編集行の表示 dsp_text_cursor(text, zs, chr_num, color_back, color_text, blink) # Full Key タッチゾーンは、このプログラムの冒頭部分で設定済み 32Pixel × 32Pixel # zone_FKs # zone_FKe # Full Key カウンタの設定 cnt_FKxy = [None, None] *key_c for i in range(key_c): cnt_FKxy[i] = [None] *key_r for x in range(key_c): for y in range(key_r): cnt_FKxy[x][y] = 0 cnt_BS = 0 cnt_Enter = 0 cnt_Shift = 0 cnt_Space = 0 mode_Shift = 0 # 0:Lower 1:Upper # 終了条件の設定 btn = '' while btn != 'Enter': get = LCD.touch_get() if get != None: # タッチされているなら X_Point = get[0] Y_Point = get[1] for x in range(key_c): for y in range(key_r): if in_zone(zone_FKs[x][y], zone_FKe[x][y], X_Point, Y_Point): if x==9 and y==0: # BS print(f'zone_BS key') cnt_BS += 1 if cnt_BS >=3: btn = 'BS' print(f'key_btn = {btn}') len_text = len(text) if len_text > 0: text = text[:len_text -1] # Keyboard 上の btn を 表示。背景を黄色、文字色は紫色 dsp_btn(mode_Shift, btn, x, y, LCD.YELLOW, LCD.PURPLE) # 編集行の表示 dsp_text_cursor(text, zs, chr_num, color_back, color_text) cnt_BS = 0 elif (x==9 and y==3) or (x==9 and y==4): # Enter print(f'zone_Enter key') cnt_Enter += 1 if cnt_Enter >=3: btn = 'Enter' print(f'key_btn = {btn}') # Keyboard 上の btn を 表示。背景を黄色、文字色は紫色 dsp_btn(mode_Shift, btn, x, y, LCD.YELLOW, LCD.PURPLE) elif (x==0 and y==5) or (x==1 and y==5): # Shift print(f'zone_Shift key') cnt_Shift += 1 if cnt_Shift >=3: btn = 'Shift' print(f'key_btn = {btn}') # mode_Shift の切り替え（反転） mode_Shift = 1 if mode_Shift == 0 else 0 # Keyboard 上の btn を 表示。背景を黄色、文字色は紫色 dsp_btn(mode_Shift, btn, x, y, LCD.YELLOW, LCD.PURPLE) cnt_Shift = 0 elif (x==2 and y==5) or (x==3 and y==5): # Space print(f'zone_Space key') cnt_Space += 1 if cnt_Space >=3: btn = 'Space' # Space print(f'key_btn = {btn}') text = text + ' ' # Keyboard 上の btn を 表示。背景を黄色、文字色は紫色 dsp_btn(mode_Shift, btn, x, y, LCD.YELLOW, LCD.PURPLE) # 編集行の表示 dsp_text_cursor(text, zs, chr_num, color_back, color_text) cnt_Space = 0 else: print(f'zone_FK{x}{y}') cnt_FKxy[x][y] += 1 if cnt_FKxy[x][y] >= TOUCH_TH: # 差分検出用に現在値を記録（Pixcel値） edt_Xs = X_Point edt_Ys = Y_Point # Full Key Btn btn = FKv0[y][x] if mode_Shift == 0 else FKv1[y][x] print(f'key_btn = {btn}') text = text + btn # Keyboard 上の btn を 表示。背景を黄色、文字色は紫色 dsp_btn(mode_Shift, btn, x, y, LCD.YELLOW, LCD.PURPLE) # 編集行の表示 dsp_text_cursor(text, zs, chr_num, color_back, color_text) cnt_FKxy[x][y] = 0 else: # get == None blink = 1 if blink == 0 else 0 # 編集行の表示 dsp_text_cursor(text, zs, chr_num, color_back, color_text, blink) # dspFillLower(LCD.WHITE) # Full Keyboard Button の表示 dsp_FullKeyboard(mode_Shift, LCD.GREEN, LCD.BLACK) # Full Key カウンタのクリア for x in range(key_c): for y in range(key_r): cnt_FKxy[x][y] = 0 cnt_BS = 0 cnt_Enter = 0 cnt_Shift = 0 cnt_Space = 0 LCD.show() return (btn, text) # Full Key による Tone Name の編集 digit_max = 最大桁数 # exeBtnName [Execute] [ OK ] などのボタン名 # Text の開始座標（余白＝背景を含む）から、chr_num で指定された桁数の編集を行う # def edit_ToneName(tone_name, digit_max, exeName): def edit_ToneName(tabM_num, tabS_num, tone_name, digit_max, exeName): blink = 0 # 上段に ガイダンスを表示 dspFillUpper(LCD.WHITE) # WindowFrame 表示 zs = [0, 50] width = 320 height = 160 # = 末尾のzs(160) - zs(50) +10(１行目余白) +30（末尾の枠＋余白） color_line = LCD.RED color_back = LCD.YELLOW dsp_WindowFrame(zs, width, height, color_line, color_back) zs = [20, 70] text = 'Put Tone SD card' color_text = LCD.RED LCD.text_scaled(text,zs[0], zs[1], color_text, 2) zs = [20, 100] text = 'Edit File Name' color_text = LCD.BLACK LCD.text_scaled(text,zs[0], zs[1], color_text, 2) # Cancel ボタンの開始座標と終末座標 text = 'Cancel' chr_num = len(text) zCANs = [30, 170] zCANe = [zCANs[0] + chr_num *chr_w, zCANs[1] + txt_h] # TAB.save_BtnCancel(zCANs, zCANe) color_line = LCD.BLACK color_back = LCD.BLUE color_text = LCD.GRAY dsp_text_frame(text, zCANs, chr_num, color_line, color_back, color_text) # OK ボタンの開始座標と終末座標を保存 text = exeName exe_num = len(text) zEXEs = [170, 170] zEXEe = [zEXEs[0] + exe_num *chr_w, zEXEs[1] + txt_h] # TAB.save_BtnExec(zEXEs, zEXEe) color_line = LCD.BLACK color_back = LCD.BLUE color_text = LCD.GRAY dsp_text_frame(text, zEXEs, exe_num, color_line, color_back, color_text) # 編集行の表示 zsTXT = [20, 120] color_back = LCD.WHITE color_text = LCD.RED dsp_text_cursor(tone_name, zsTXT, digit_max +1, color_back, color_text, blink) LCD.show() # Main Tab の座標リストを取得 zoneMtab_s = TAB.get_zoneMtab_s() zoneMtab_e = TAB.get_zoneMtab_e() # Sub Tab の座標リストを取得 zoneStab_s = TAB.get_zoneStab_s() zoneStab_e = TAB.get_zoneStab_e() # cnt_tabM cnt_tabS cntOP の初期化 cnt_tabM = [None] * 5 cnt_tabS = [None] * 5 for i in range(5): cnt_tabM[i] = 0 cnt_tabS[i] = 0 # Full Key タッチゾーンは、プログラムの冒頭部分で設定済み 32Pixel × 32Pixel # zone_FKs # zone_FKe # Full Key カウンタの設定 cnt_FKxy = [None, None] *key_c for i in range(key_c): cnt_FKxy[i] = [None] *key_r for x in range(key_c): for y in range(key_r): cnt_FKxy[x][y] = 0 cnt_BS = 0 cnt_Enter = 0 cnt_Shift = 0 cnt_Space = 0 mode_Shift = 0 # 0:Lower 1:Upper cnt_Exe = 0 cnt_Can = 0 # 終了条件の設定 tabM_num_old = tabM_num tabS_num_old = tabS_num btn = '' # (btn == 'Enter' or btn == 'Cancel' or btn == exeName) ならば終了 # while not(btn == 'Enter' or btn == 'Cancel' or btn == exeName): while tabM_num_old == tabM_num and tabS_num_old == tabS_num \ and not(btn == 'Enter' or btn == 'Cancel' or btn == exeName): # カーソルの点滅 blink = 1 if blink == 0 else 0 # 編集行の表示 dsp_text_cursor(tone_name, zsTXT, digit_max, color_back, color_text, blink) # Full Keyboard Button の表示 dsp_FullKeyboard(mode_Shift, LCD.GREEN, LCD.BLACK) get = LCD.touch_get() if get != None: # タッチされているなら X_Point = get[0] Y_Point = get[1] # Execute ボタンが押されたら終了 if in_zone(zEXEs, zEXEe, X_Point, Y_Point): # print(f'{exeName} Button') cnt_Exe += 1 if cnt_Exe == TOUCH_TH: btn = exeName print(f'btn = {btn}') # 選択されたボタンの色を変える dsp_text_frame(exeName, zEXEs, exe_num, LCD.BLACK, LCD.GREEN, LCD.RED) # Cancel ボタンが押されたら終了 elif in_zone(zCANs, zCANe, X_Point, Y_Point): print('Cancel Button') cnt_Can += 1 if cnt_Can == TOUCH_TH: btn = 'Cancel' # 選択されたボタンの色を変える text = 'Cancel' chr_num = len(text) color_line = LCD.BLACK color_back = LCD.GREEN color_text = LCD.RED dsp_text_frame(text, zCANs, chr_num, color_line, color_back, color_text) # mainTab のタッチで終了 elif in_zone(zoneMtab_s[1], zoneMtab_e[4], X_Point, Y_Point): for i in range(1, 5): if in_zone(zoneMtab_s[i], zoneMtab_e[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば # print(f'select zoneMtab[{i}]') cnt_tabM[i] += 1 if cnt_tabM[i] == TOUCH_TH: tabM_num = i print(f'main-menu Select = {tabM_num}') # subTab のタッチで終了 elif in_zone(zoneStab_s[1], zoneStab_e[4], X_Point, Y_Point): for i in range(1, 5): if in_zone(zoneStab_s[i], zoneStab_e[i], X_Point, Y_Point): # zoneMtab[i] の周辺ならば # print(f'select zoneStab[{i}]') cnt_tabS[i] += 1 if cnt_tabS[i] == TOUCH_TH: tabS_num = i print(f'sub-menu Select = {tabS_num}') for x in range(key_c): for y in range(key_r): if in_zone(zone_FKs[x][y], zone_FKe[x][y], X_Point, Y_Point): if x==9 and y==0: # BS # print(f'zone_BS key') cnt_BS += 1 if cnt_BS ==3: btn = 'BS' print(f'key_btn = {btn}') len_text = len(tone_name) if len_text > 0: tone_name = tone_name[:len_text -1] # Keyboard 上の btn を 表示。背景を黄色、文字色は紫色 dsp_btn(mode_Shift, btn, x, y, LCD.YELLOW, LCD.PURPLE) # 編集行の表示 dsp_text_cursor(tone_name, zsTXT, digit_max, color_back, color_text, blink) cnt_BS = 0 elif (x==9 and y==3) or (x==9 and y==4): # Enter print(f'zone_Enter key') cnt_Enter += 1 if cnt_Enter ==3: btn = 'Enter' print(f'key_btn = {btn}') # Keyboard 上の btn を 表示。背景を黄色、文字色は紫色 dsp_btn(mode_Shift, btn, x, y, LCD.YELLOW, LCD.PURPLE) elif (x==0 and y==5) or (x==1 and y==5): # Shift # print(f'zone_Shift key') cnt_Shift += 1 if cnt_Shift ==3: btn = 'Shift' print(f'key_btn = {btn}') # mode_Shift の切り替え（反転） mode_Shift = 1 if mode_Shift == 0 else 0 # Keyboard 上の btn を 表示。背景を黄色、文字色は紫色 dsp_btn(mode_Shift, btn, x, y, LCD.YELLOW, LCD.PURPLE) cnt_Shift = 0 elif (x==2 and y==5) or (x==3 and y==5): # Space # print(f'zone_Space key') cnt_Space += 1 if cnt_Space ==3: btn = 'Space' # Space print(f'key_btn = {btn}') # Keyboard 上の btn を 表示。背景を黄色、文字色は紫色 dsp_btn(mode_Shift, btn, x, y, LCD.YELLOW, LCD.PURPLE) if len(tone_name) < digit_max: # digit_max 未満ならば tone_name = tone_name + ' ' # 編集行の表示 dsp_text_cursor(tone_name, zsTXT, digit_max, color_back, color_text) cnt_Space = 0 else: # print(f'zone_FK{x}{y}') cnt_FKxy[x][y] += 1 if cnt_FKxy[x][y] == TOUCH_TH: # 差分検出用に現在値を記録（Pixcel値） edt_Xs = X_Point edt_Ys = Y_Point # Full Key Btn btn = FKv0[y][x] if mode_Shift == 0 else FKv1[y][x] print(f'key_btn = {btn}') # Keyboard 上の btn を 表示。背景を黄色、文字色は紫色 dsp_btn(mode_Shift, btn, x, y, LCD.YELLOW, LCD.PURPLE) if len(tone_name) < digit_max: # digit_max 未満ならば tone_name = tone_name + btn # 編集行の表示 dsp_text_cursor(tone_name, zsTXT, digit_max, color_back, color_text) cnt_FKxy[x][y] = 0 else: # get == None # cnt_tabM cnt_tabS cntOP の タッチカウントのクリア for i in range(5): cnt_tabM[i] = 0 cnt_tabS[i] = 0 # Full Key タッチカウントのクリア for x in range(key_c): for y in range(key_r): cnt_FKxy[x][y] = 0 cnt_BS = 0 cnt_Enter = 0 cnt_Shift = 0 cnt_Space = 0 cnt_Exe = 0 cnt_Can = 0 LCD.show() return (tabM_num, tabS_num, btn, tone_name) ``` ### touch_lcd.py ```MicroPython:touch_lcd.py ######################################################################## # WAVE SHARE Pico-ResTouch-LCD-3.5 で用意された main_3inch5.py をテスト・改良 # # 2025/08/28 : touch_lcd_No3_WS\ALG-033.py からライブラリとして独立させた # touch_lcd-yyyymmdd-hhmm.py # # タッチパネルの調整用のプログラムは残した状態 # ######################################################################## from machine import Pin,SPI,PWM from micropython import const import math import framebuf import time import os import gc # メモリ利用状況表示用 ############################################################################## # for DEBUG # PRINT_TOUCH_POS = True # タッチ座標を表示する時 # TOUCH_ADJ = True # タッチ座標を取得する時。ROTATE = const(180) にすること # 2025/09/26 PRINT_TOUCH_POS = False # タッチ座標を表示しない TOUCH_ADJ = False # タッチ座標を取得しない ############################################################################## LCD_DC = const(8) LCD_CS = const(9) LCD_SCK = const(10) LCD_MOSI = const(11) LCD_MISO = const(12) LCD_BL = const(13) LCD_RST = const(15) TP_CS = const(16) TP_IRQ = const(17) ############################################################## # LCDの向きに合わせて設定する # Set the rotation Angle to 0°, 90°, 180° or 270° # 0:USBが左辺上 90:USBが下辺左 180:USBが右辺下 270:USBが上辺右 # タッチ座標を取得して調整するときは。ROTATE = const(180) にすること ############################################################## ROTATE = const(180) # この Pixel 分を上下左右に拡大したエリアをタッチ有効とする # 一部、この倍の領域にしている TOUCH = const(8) class LCD_3inch5(framebuf.FrameBuffer): def __init__(self): self.RED = 0x07E0 self.GREEN = 0x001f self.BLUE = 0xf800 self.WHITE = 0xffff self.BLACK = 0x0000 # Return color565 from RGB color value. # Red Green Blue self.YELLOW = self.rgb2color565(0xFF, 0xFF, 0x00) self.PURPLE = self.rgb2color565(0xFF, 0x00, 0xFF) self.BLUEGREEN = self.rgb2color565(0x00, 0xFF, 0xFF) self.GRAY = self.rgb2color565(0x50, 0x28, 0x15) self.rotate = ROTATE # 2025/07/15 ここの設定の修正が必要だった if self.rotate == 0 or self.rotate == 180: self.width = 320 # 2025/07/15 self.height = 240 self.height = 480 else: self.width = 480 # 2025/07/15 self.height = 160 self.height = 320 # 制御信号端子の設定 self.cs = Pin(LCD_CS,Pin.OUT) self.rst = Pin(LCD_RST,Pin.OUT) self.dc = Pin(LCD_DC,Pin.OUT) self.tp_cs =Pin(TP_CS,Pin.OUT) self.irq = Pin(TP_IRQ,Pin.IN) # 制御信号端子の初期状態設定 self.cs(1) self.dc(1) self.rst(1) self.tp_cs(1) # Before LCD(ILI9488) 40MHz # self.spi_lcd = SPI(1,baudrate=40_000_000,sck=Pin(LCD_SCK),\ # mosi=Pin(LCD_MOSI),miso=Pin(LCD_MISO)) # # 2025/09/05 After LCD(ILI9488) 20MHz self.spi_lcd = SPI(1,baudrate=20_000_000,sck=Pin(LCD_SCK),\ mosi=Pin(LCD_MOSI),miso=Pin(LCD_MISO)) print(self.spi_lcd) #################### このあたりが難解 ################################ # Pico2(RP2350) ならば、画面一杯をしてしてもメモリエラーにならない self.buffer = bytearray(self.height * self.width * 2) super().__init__(self.buffer, self.width, self.height, framebuf.RGB565) ######################################################################### ############################################################# print(f'touch_lcd Start ... gc.mem_alloc() = {gc.mem_alloc()}') # メモリ未使用を示されても分かりにくい、やめ。 # print('gc.mem_free() = ', gc.mem_free()) # メモリ未使用 ############################################################# self.init_display() # color565 is Blue:5bits, Red:6bits, and Green:5bits 16bits # Return color565 from RGB color value. def rgb2color565(self, r, g, b): return (r & 0xFC) << 3 | (g & 0xF8) >> 3 | (b & 0xF8) << 8 def init_display(self): self.rst(0) time.sleep_ms(17) self.rst(1) time.sleep_ms(47) # INVON = const(0x21) # Display inversion on self.write_cmd(0x21) # Power Control 3 self.write_cmd(0xC2) self.write_data(0x33) # VMCTR1 = const(0xC5) # VCOM control 1 self.write_cmd(0xC5) self.write_data(0x00) self.write_data(0x1e) self.write_data(0x80) # FRMCTR1 = const(0xB1) # Frame rate control (In normal mode/full colors) self.write_cmd(0xB1) self.write_data(0xB0) # GMCTRP1 = const(0xE0) # Positive gamma correction self.write_cmd(0xE0) self.write_data(0x00) self.write_data(0x13) self.write_data(0x18) self.write_data(0x04) self.write_data(0x0F) self.write_data(0x06) self.write_data(0x3a) self.write_data(0x56) self.write_data(0x4d) self.write_data(0x03) self.write_data(0x0a) self.write_data(0x06) self.write_data(0x30) self.write_data(0x3e) self.write_data(0x0f) # GMCTRN1 = const(0xE1) # Negative gamma correction self.write_cmd(0xE1) self.write_data(0x00) self.write_data(0x13) self.write_data(0x18) self.write_data(0x01) self.write_data(0x11) self.write_data(0x06) self.write_data(0x38) self.write_data(0x34) self.write_data(0x4d) self.write_data(0x06) self.write_data(0x0d) self.write_data(0x0b) self.write_data(0x31) self.write_data(0x37) self.write_data(0x0f) # PIXFMT = const(0x3A) # COLMOD: Pixel format set self.write_cmd(0x3A) self.write_data(0x55) # 16bits/pixel # SLPOUT = const(0x11) # Exit sleep mode self.write_cmd(0x11) time.sleep_ms(117) self.write_cmd(0x29) # DFUNCTR = const(0xB6) # Display function control self.write_cmd(0xB6) self.write_data(0x00) self.write_data(0x62) # MADCTL = const(0x36) # Memory access control self.write_cmd(0x36) # Sets the memory access mode for rotation # bit 7-6:パネル方向 bit 5=0:横長 1:縦長 # bit 3は、常に1 bit 7654 3210 if self.rotate == 0: self.write_data(0x88) # 1000 1000 elif self.rotate == 180: self.write_data(0x48) # 0100 1000 elif self.rotate == 90: self.write_data(0xe8) # 1110 1000 else: self.write_data(0x28) # 0010 1000 def write_cmd(self, cmd): self.cs(1) self.dc(0) self.cs(0) self.spi_lcd.write(bytearray([cmd])) self.cs(1) def write_data(self, buf): self.cs(1) self.dc(1) self.cs(0) #self.spi_lcd.write(bytearray([0x00])) self.spi_lcd.write(bytearray([buf])) self.cs(1) # 全エリアに描画 def show(self): if self.rotate == 0 or self.rotate == 180: # SET_COLUMN = const(0x2A) # Column address set self.write_cmd(0x2A) self.write_data(0x00) # Start Column self.write_data(0x00) # 0x0000 self.write_data(0x01) # End Column self.write_data(0x3f) # 0x013f:319 # SET_PAGE = const(0x2B) # Page address set self.write_cmd(0x2B) self.write_data(0x00) # Start Page self.write_data(0x00) # 0x0000 self.write_data(0x01) # End Page self.write_data(0xdf) # 0x01df:479 else: # self.rotate == 90 or self.rotate == 270: # SET_COLUMN = const(0x2A) # Column address set self.write_cmd(0x2A) self.write_data(0x00) # Start Column self.write_data(0x00) # 0x0000 self.write_data(0x01) # End Column self.write_data(0xdf) # 0x01df:479 # SET_PAGE = const(0x2B) # Page address set self.write_cmd(0x2B) self.write_data(0x00) # Start Page self.write_data(0x00) # 0x0000 self.write_data(0x01) # End Page self.write_data(0x3f) # 0x013f:319 # WRITE_RAM = const(0x2C) # Memory write self.write_cmd(0x2C) self.cs(1) self.dc(1) self.cs(0) self.spi_lcd.write(self.buffer) self.cs(1) # 2025/06/29 Add # 拡大表示するテキスト描画関数 # scale:拡大率（整数） def text_scaled(self, text, x, y, color, scale=1): # 一時的なフレームバッファを作成（文字描画用） temp_fb = framebuf.FrameBuffer(bytearray(8 * len(text) * 8),\ 8 * len(text), 8, framebuf.MONO_HLSB) temp_fb.fill(0) # 背景をクリア temp_fb.text(text, 0, 0, 1) # 文字を描画 # 各ピクセルを拡大して描画 for yy in range(8): for xx in range(8 * len(text)): if temp_fb.pixel(xx, yy): # 文字のピクセルがある場合 self.fill_rect(x + xx * scale, y + yy * scale,\ scale, scale, color) def bl_ctrl(self,duty): pwm = PWM(Pin(LCD_BL)) pwm.freq(1000) if(duty>=100): pwm.duty_u16(65535) else: pwm.duty_u16(655*duty) def touch_get(self): if self.irq() == 0: # spi1 Switching to Touch Panel # 2025/07/03 : 使用都度、設定し直す、この方法が良いようだ。 # Touch Panel(XPT2046) 4MHz self.spi_touch = SPI(1, baudrate=4_000_000, sck=Pin(LCD_SCK),\ mosi=Pin(LCD_MOSI), miso=Pin(LCD_MISO)) self.tp_cs(0) time.sleep_ms(1) for i in range(0,3): self.spi_touch.write(bytearray([0xD0])) Read_date = self.spi_touch.read(2) time.sleep_us(17) x_touch = ((Read_date[0] <<8) + Read_date[1]) >>3 self.spi_touch.write(bytearray([0x90])) Read_date = self.spi_touch.read(2) time.sleep_us(17) y_touch = ((Read_date[0] <<8) + Read_date[1]) >>3 time.sleep_ms(1) self.tp_cs(1) # DEBUG ADJ 用 #################################################### if PRINT_TOUCH_POS: print('x_touch = ', x_touch, ' y_touch = ', y_touch) ################################################################### # spi1 Switching to LCD # 2025/07/03 : 使用が終われば、設定を元に戻す。この方法が良いようだ。 # Before LCD(ILI9488) 40MHz # self.spi_lcd = SPI(1, baudrate=40_000_000, sck=Pin(LCD_SCK),\ # mosi=Pin(LCD_MOSI), miso=Pin(LCD_MISO)) # # 2025/09/05 After LCD(ILI9488) 20MHz self.spi_lcd = SPI(1,baudrate=20_000_000,sck=Pin(LCD_SCK),\ mosi=Pin(LCD_MOSI),miso=Pin(LCD_MISO)) ############################## # Set Here Adjuste Parameter # x_min ===> x_max # 4800 7350 # y_min ----------------- # | | # 4700 | + + | # | | # | LCD Panel | # | |_ # | | | USB connector # 7700 | + + |~ # | | # y_max ----------------- # ~~ USB connector ########################################################### # 2025/07/24 ADJ # 四隅ではなく、各40Pixcel 中央寄りの四隅の値を基準に決める方法に変更 # 2025/08/14 Adj No3 Touch LCD # 左上の XT XY の値 result40_40 = [4800,4720] # [4900,4800] # 右上の XT XY の値 result280_40 = [7400,4720] # [7450,4800] # 左下の XT XY の値 result40_440 = [4800,7700] # [4900,7800] # 右下の XT XY の値 result280_440 = [7400,7700] # [7450,7800] # 右下の XT XY の値は、利用していない x_min = int(result40_40[0] - ((result280_40[0] - result40_40[0]) *40 /(280 -40))) x_max = int(result280_40[0] + ((result280_40[0] - result40_40[0]) *40 /(280 -40))) y_min = int(result40_40[1] - ((result40_440[1] - result40_40[1]) *40 /(440 -40))) y_max = int(result40_440[1] + ((result40_440[1] - result40_40[1]) *40 /(440 -40))) ######################### x_range = x_max - x_min y_range = y_max - y_min ######################### # Result_list = [touch_,touch_Y] # 2025/07/02 : self.rotate の方向で、LCD位置に合わせた座標を返す if self.rotate == 0 or self.rotate == 180: if self.rotate == 0: # X軸Y軸の座標入替なし and X軸Y軸とも 数値変換なし X_Point = 320 - int((x_touch - x_min) *320 /x_range) Y_Point = 480 - int((y_touch - y_min) *480 /y_range) elif self.rotate == 180: # X軸Y軸の座標入替なし and Y軸は 数値大小入替 X_Point = int((x_touch - x_min) *320 /x_range) Y_Point = int((y_touch - y_min) *480 /y_range) # 範囲内に収める 2025/07/17 修正 if X_Point >= 320: X_Point = 319 elif X_Point < 0: X_Point = 0 if Y_Point >= 480: Y_Point = 479 elif Y_Point < 0: Y_Point = 0 else: # self.rotate == 90 or self.rotate == 270: if self.rotate == 90: # X軸Y軸の座標入替あり and X軸は 数値大小入替 X_Point = 480 - int((y_touch - y_min) *480 /y_range) Y_Point = int((x_touch - x_min) *320 /x_range) elif self.rotate == 270: # X軸Y軸の座標入替あり and Y軸は 数値大小入替 X_Point = int((y_touch - y_min) *480 /y_range) Y_Point = 320 - int((x_touch - x_min) *320 /x_range) # 範囲内に収める 2025/07/17 修正 if X_Point >= 480: X_Point = 479 elif X_Point < 0: X_Point = 0 if Y_Point >= 320: Y_Point = 319 elif Y_Point < 0: Y_Point = 0 if TOUCH_ADJ: # タッチポイント調整用に生のポイントデータを返す # 2025/07/23 Result_list = [X_Point, Y_Point, x_touch, y_touch] else: # LCD Pixcel に変換したデータのみを返す Result_list = [X_Point, Y_Point] if PRINT_TOUCH_POS: # タッチされた座標を表示 print(Result_list) return(Result_list) def spi_change2_lcd(): # SD-Card 処理後にSPI-1 の設定を LCD に戻す # 2025/09/05 After LCD(ILI9488) 20MHz self.spi_lcd = SPI(1,baudrate=20_000_000,sck=Pin(LCD_SCK),\ mosi=Pin(LCD_MOSI),miso=Pin(LCD_MISO)) if __name__=='__main__': LCD = LCD_3inch5() LCD.bl_ctrl(100) print('LCD.rotate = ', LCD.rotate) LCD.fill(LCD.WHITE) X_Point_Old = 0 Y_Point_Old = 0 #調整用ポイントの座標の設定 # TOUCH_ADJ = True # ROTATE = const(180) にすること if LCD.rotate == 0 or LCD.rotate == 180: # 縦長表示 の直後 # 調整用ポイントの座標の設定 pos40_40 = [ 40, 40] pos280_40 = [280, 40] pos40_440 = [ 40,440] pos280_440 = [280,440] #color BRG LCD.fill(LCD.WHITE) # 調整用ポイントの座標を 5Pixel x 5Pixel で表示する LCD.fill_rect(pos40_40[0]-2, pos40_40[1]-2, 5, 5, LCD.RED) LCD.fill_rect(pos280_40[0]-2, pos280_40[1]-2, 5, 5, LCD.RED) LCD.fill_rect(pos40_440[0]-2, pos40_440[1]-2, 5, 5, LCD.RED) LCD.fill_rect(pos280_440[0]-2, pos280_440[1]-2, 5, 5, LCD.RED) LCD.show() scope = 10 # 移動平均 Average 個数 X_listT = [None] * scope Y_listT = [None] * scope X_listL = [None] * scope Y_listL = [None] * scope cnt_scope = 0 # 各ポジションの集計結果を利用可能（10回以上計測）になればセット flag40_40 = 0 flag280_40 = 0 flag40_440 = 0 flag280_440 = 0 # 測定結果が出たらセット flag_result = 0 # Touch Point 表示 while True: get = LCD.touch_get() if get != None: # タッチされているなら if TOUCH_ADJ: # 調整モードなら、タッチ生データ get[2], get[3] を取得 X_PointL = get[0] Y_PointL = get[1] X_PointT = get[2] Y_PointT = get[3] else: # LCD 座標変換データ取得 X_PointL = get[0] Y_PointL = get[1] # 移動平均計算用にデータを記録 X_listL[cnt_scope] = X_PointL Y_listL[cnt_scope] = Y_PointL X_listT[cnt_scope] = X_PointT Y_listT[cnt_scope] = Y_PointT if flag_result == 0: cnt_scope += 1 if cnt_scope >= scope: cnt_scope = 0 if flag_result == 0: flag_result = 1 else: # 移動平均 10 計算 X_totalL = 0 Y_totalL = 0 X_totalT = 0 Y_totalT = 0 for i in range(scope): X_totalL += X_listL[i] Y_totalL += Y_listL[i] X_totalT += X_listT[i] Y_totalT += Y_listT[i] # 移動平均 10 X_aveL = int(X_totalL / scope) Y_aveL = int(Y_totalL / scope) X_aveT = int(X_totalT / scope) Y_aveT = int(Y_totalT / scope) # 領域別に表示 # 初期状態 中心と思われる 4800 4700 の +400 +400 if X_aveT < 5200 and Y_aveT < 5100: # pos40_40 の 値を収録 ave40_40 = [X_aveT, Y_aveT] flag40_40 += 1 if flag40_40 >= 10: # 文字領域を 白色にしてから表示 LCD.fill_rect(20,80,16*8,80, LCD.WHITE) LCD.text_scaled(f'XL:{X_aveL}',20, 80,LCD.BLUE, 2) LCD.text_scaled(f'XT:{X_aveT}',20,100,LCD.BLUE, 2) LCD.text_scaled(f'YL:{Y_aveL}',20,120,LCD.BLUE, 2) LCD.text_scaled(f'YT:{Y_aveT}',20,140,LCD.BLUE, 2) # 初期状態 中心と思われる 7350 4700 の -400 +400 elif X_aveT > 6950 and Y_aveT < 5100: # pos280_40 の 値を収録 ave280_40 = [X_aveT, Y_aveT] flag280_40 += 1 if flag280_40 >= 10: # 文字領域を 白色にしてから表示 LCD.fill_rect(180,80,16*8,80, LCD.WHITE) LCD.text_scaled(f'XL:{X_aveL}',180, 80,LCD.BLUE, 2) LCD.text_scaled(f'XT:{X_aveT}',180,100,LCD.BLUE, 2) LCD.text_scaled(f'YL:{Y_aveL}',180,120,LCD.BLUE, 2) LCD.text_scaled(f'YT:{Y_aveT}',180,140,LCD.BLUE, 2) # 初期状態 中心と思われる 4800 7700 の +400 -400 elif X_aveT < 5200 and Y_aveT > 7300: # pos40_440 の 値を収録 ave40_440 = [X_aveT, Y_aveT] flag40_440 += 1 if flag40_440 >= 10: # 文字領域を 白色にしてから表示 LCD.fill_rect(20,340,16*8,80, LCD.WHITE) LCD.text_scaled(f'XL:{X_aveL}',20,340,LCD.BLUE, 2) LCD.text_scaled(f'XT:{X_aveT}',20,360,LCD.BLUE, 2) LCD.text_scaled(f'YL:{Y_aveL}',20,380,LCD.BLUE, 2) LCD.text_scaled(f'YT:{Y_aveT}',20,400,LCD.BLUE, 2) # 初期状態 中心と思われる 7350 7700 の -400 -400 elif X_aveT > 6950 and Y_aveT > 7300: # pos280_440 の 値を収録 ave280_440 = [X_aveT, Y_aveT] flag280_440 += 1 if flag280_440 >= 10: # 文字領域を 白色にしてから表示 LCD.fill_rect(180,340,16*8,80, LCD.WHITE) LCD.text_scaled(f'XL:{X_aveL}',180,340,LCD.BLUE, 2) LCD.text_scaled(f'XT:{X_aveT}',180,360,LCD.BLUE, 2) LCD.text_scaled(f'YL:{Y_aveL}',180,380,LCD.BLUE, 2) LCD.text_scaled(f'YT:{Y_aveT}',180,400,LCD.BLUE, 2) # 四隅のデータが揃ったら結果を表示する if flag280_40 >= 10 and flag280_40 >= 10 and flag40_440 >= 10 and flag280_440 >= 10: LCD.fill_rect(10,200,310,120, LCD.WHITE) LCD.text_scaled(f'Set def Result Data',10,200,LCD.BLACK, 2) LCD.text_scaled(f'def touch_get(self):',10,220,LCD.BLACK, 2) LCD.text_scaled(f'rt40_40 ={ave40_40[0]},{ave40_40[1]}',10,240,LCD.BLACK, 2) LCD.text_scaled(f'rt280_40 ={ave280_40[0]},{ave280_40[1]}',10,260,LCD.BLACK, 2) LCD.text_scaled(f'rt40_440 ={ave40_440[0]},{ave40_440[1]}',10,280,LCD.BLACK, 2) LCD.text_scaled(f'rt280_440={ave280_440[0]},{ave280_440[1]}',10,300,LCD.BLACK, 2) LCD.show() else: cnt_scope = 0 flag_result = 0 time.sleep_ms(47) ``` ### tab_cdn.py ```MicroPython:tab_cdn.py ######################################################################## # main-menu と sub-menu の タブを表示させるための座標提供 # tab_cdn_yyyymmdd-hhmm.py # # エクスポート可能 # main-menu と sub-menu の タブの座標（開始座標と終末座標）を # 他の関数に提供する # ######################################################################## import time from micropython import const ################################################# # MicroPython ################################################# class TabCoordinate: def __init__(self): # 初期設定 self.Item = 5 self.Mxs = 0 self.Mys = 0 self.Sxs = 0 self.Sys = 240 self.UPys = 24 self.LWys = 264 self.UPzs = [0, self.UPys] self.LWzs = [0, self.LWys] self.chr_n = 4 # タブの文字数 self.chr_w = 16 # 文字幅 self.chr_h = 16 # 文字高さ self.xb = 4 # 縦線幅 x self.yb = 4 # 横線幅 y # タブの全体幅 80 self.w = self.chr_n *self.chr_w + self.xb *4 # タブの全体高さ 24 self.h = self.chr_h + self.yb *2 # main-tab と sub-tab の表示内容 self.tabMain_text = [' ', 'get ', 'com ', ' op ', 'put '] self.tabCOM_text = [' ', 'ALG ', ' BO ', 'LFO ', ' '] self.tabOP_text = [' ', ' WS ', 'MUL ', 'ADSR', 'DAM '] self.tabGET_text = [' ', ' MR ', ' SD ', ' ', ' '] self.tabPUT_text = [' ', 'YMF ', ' SD ', ' ', 'MODE'] # main-tab と sub-tab の開始座標 self.zoneMtab_s = [[self.Mxs +self.xb +self.w*0,self.Mys],\ [self.Mxs +self.xb +self.w*0,self.Mys],\ [self.Mxs +self.xb +self.w*1,self.Mys],\ [self.Mxs +self.xb +self.w*2,self.Mys],\ [self.Mxs +self.xb +self.w*3,self.Mys]] self.zoneStab_s = [[self.Sxs +self.xb +self.w*0,self.Sys],\ [self.Sxs +self.xb +self.w*0,self.Sys],\ [self.Sxs +self.xb +self.w*1,self.Sys],\ [self.Sxs +self.xb +self.w*2,self.Sys],\ [self.Sxs +self.xb +self.w*3,self.Sys]] # main-tab と sub-tab の終了座標 他のクラスへのエクスポート用 self.zoneMtab_e = [None] * self.Item self.zoneStab_e = [None] * self.Item # Oparation No Tab の開始座標と終末座標 self.zOPs = [None] * self.Item self.zOPe = [None] * self.Item for i in range(self.Item): self.zoneMtab_e[i] = [self.zoneMtab_s[i][0]+self.w, self.zoneMtab_s[i][1]+self.h] self.zoneStab_e[i] = [self.zoneStab_s[i][0]+self.w, self.zoneStab_s[i][1]+self.h] self.zOPs[i] = 0 self.zOPe[i] = 0 # ALG ラベルの開始座標と終末座標の準備 alg_num = 8 self.zALGs = [None] *alg_num self.zALGe = [None] *alg_num for i in range(alg_num): self.zALGs[i] = 0 self.zALGe[i] = 0 # タブの座標 リスト提供 def get_zoneMtab_s(self): return self.zoneMtab_s def get_zoneMtab_e(self): return self.zoneMtab_e def get_zoneStab_s(self): return self.zoneStab_s def get_zoneStab_e(self): return self.zoneStab_e # タブのテキストをリストで提供 def get_tabMain_text(self): return self.tabMain_text def get_tabCOM_text(self): return self.tabCOM_text def get_tabOP_text(self): return self.tabOP_text def get_tabGET_text(self): return self.tabGET_text def get_tabPUT_text(self): return self.tabPUT_text # 個別タブの開始座標と終末座標の提供 def get_zMs(self, num): return self.zoneMtab_s[num] def get_zMe(self, num): return self.zoneMtab_e[num] # メニュー・タブの開始座標と終末座標の提供 def get_zSs(self, num): return self.zoneStab_s[num] def get_zSe(self, num): return self.zoneStab_e[num] # 上段の表示エリアと下段表示エリアの情報 def get_UpperAria(self): # 開始座標 幅 高さ return (self.UPzs, 320, 240-24) def get_LowerAria(self): # 開始座標 幅 高さ return (self.LWzs, 320, 240-24) # 上段表示エリアの開始座標と終末座標の提供 def get_zUPs(self): # 開始座標 幅 高さ # return (self.UPzs, 320, 240-24) return (self.UPzs) def get_zUPe(self): # 開始座標 幅 高さ # return (self.UPzs, 320, 240-24) return (self.UPzs[0] +320, self.UPzs[1] +(240-24)) # 下段表示エリアの開始座標と終末座標の提供 def get_zLWs(self): # 開始座標 幅 高さ # return (self.LWzs, 320, 240-24) return (self.LWzs) def get_zLWe(self): # 開始座標 幅 高さ # return (self.LWzs, 320, 240-24) return (self.LWzs[0] +320, self.LWzs[1] +(240-24)) # tone_edit の関数 alg_zl_save() からセットする # 上段に表示する時の op1 ~ op4 の zl 座標 ・・・ 中心線の開始座標である # alg_patarn(alg, stage, color_line, color_back, color_text) # を利用するのに便利 def alg_zlOP_save(self, zlOP): self.zlOP = zlOP def get_zlOP(self): return self.zlOP # tone_edit の関数 alg_zs_save() からセットする op1 ~ op4 の開始座標と終末座標 # タッチセンス用の座標である def alg_zOP_save(self, zOP1s, zOP1e, zOP2s, zOP2e, zOP3s, zOP3e, zOP4s, zOP4e): # 存在しない self.zOPs[0] = [0, 0] self.zOPe[0] = [0, 0] # タッチエリアを上下に 8Pixel 拡大 self.zOPs[1] = [zOP1s[0], zOP1s[1] -8] self.zOPe[1] = [zOP1e[0], zOP1e[1] +8] self.zOPs[2] = [zOP2s[0], zOP2s[1] -8] self.zOPe[2] = [zOP2e[0], zOP2e[1] +8] self.zOPs[3] = [zOP3s[0], zOP3s[1] -8] self.zOPe[3] = [zOP3e[0], zOP3e[1] +8] self.zOPs[4] = [zOP4s[0], zOP4s[1] -8] self.zOPe[4] = [zOP4e[0], zOP4e[1] +8] # ALG op1 ~ op4 の開始座標の提供 def get_zOPs(self): return self.zOPs # ALG op1 ~ op4 の終末座標の提供 def get_zOPe(self): return self.zOPe # alg0 ~ alg7 表示ラベルの開始座標と終末座標 # tone_edit の関数 alg_zALG_save() からセットする def alg_zALG_save(self, alg_LBs, alg_LBe): self.alg_LBs = alg_LBs self.alg_LBe = alg_LBe # ALG 表示ラベルの開始座標リストで提供 def get_zALGs(self): # return self.zALGs return self.alg_LBs # ALG 表示ラベルの終末座標リストで提供 def get_zALGe(self): # return self.zALGe return self.alg_LBe # tone_edit の関数 def wave_form() の中の # TAB.zWS_save(zWSs, zWSe) からセットする WS:0 ~ WS:30 の開始座標と終末座標 def zWS_save(self, zWSs, zWSe): self.zWSs = zWSs self.zWSe = zWSe # WS:0 ~ WS:30 の開始座標をリストで提供 def get_zWSs(self): return self.zWSs # WS:0 ~ WS:30 の終末座標をリストで提供 def get_zWSe(self): return self.zWSe def save_BtnExec(self, zEXEs, zEXEe): self.zEXEs = zEXEs self.zEXEe = zEXEe def save_BtnCansel(self, zCANs, zCANe): self.zCANs = zCANs self.zCANe = zCANe def get_zEXEs(self): return self.zEXEs def get_zEXEe(self): return self.zEXEe def get_zCANs(self): return self.zCANs def get_zCANe(self): return self.zCANe ``` ### sdcard.py ```MicroPython:sdcard.py """ MicroPython driver for SD cards using SPI bus. Requires an SPI bus and a CS pin. Provides readblocks and writeblocks methods so the device can be mounted as a filesystem. Example usage on pyboard: import pyb, sdcard, os sd = sdcard.SDCard(pyb.SPI(1), pyb.Pin.board.X5) pyb.mount(sd, '/sd2') os.listdir('/') Example usage on ESP8266: import machine, sdcard, os sd = sdcard.SDCard(machine.SPI(1), machine.Pin(15)) os.mount(sd, '/sd') os.listdir('/') """ from micropython import const import time _CMD_TIMEOUT = const(100) _R1_IDLE_STATE = const(1 << 0) # R1_ERASE_RESET = const(1 << 1) _R1_ILLEGAL_COMMAND = const(1 << 2) # R1_COM_CRC_ERROR = const(1 << 3) # R1_ERASE_SEQUENCE_ERROR = const(1 << 4) # R1_ADDRESS_ERROR = const(1 << 5) # R1_PARAMETER_ERROR = const(1 << 6) _TOKEN_CMD25 = const(0xFC) _TOKEN_STOP_TRAN = const(0xFD) _TOKEN_DATA = const(0xFE) class SDCard: def __init__(self, spi, cs, baudrate=1320000): self.spi = spi self.cs = cs self.cmdbuf = bytearray(6) self.dummybuf = bytearray(512) self.tokenbuf = bytearray(1) for i in range(512): self.dummybuf[i] = 0xFF self.dummybuf_memoryview = memoryview(self.dummybuf) # initialise the card self.init_card(baudrate) def init_spi(self, baudrate): try: master = self.spi.MASTER except AttributeError: # on ESP8266 self.spi.init(baudrate=baudrate, phase=0, polarity=0) else: # on pyboard self.spi.init(master, baudrate=baudrate, phase=0, polarity=0) def init_card(self, baudrate): # init CS pin self.cs.init(self.cs.OUT, value=1) # init SPI bus; use low data rate for initialisation self.init_spi(100000) # clock card at least 100 cycles with cs high for i in range(16): self.spi.write(b"\xff") # CMD0: init card; should return _R1_IDLE_STATE (allow 5 attempts) for _ in range(5): if self.cmd(0, 0, 0x95) == _R1_IDLE_STATE: break else: raise OSError("no SD card") # CMD8: determine card version r = self.cmd(8, 0x01AA, 0x87, 4) if r == _R1_IDLE_STATE: self.init_card_v2() elif r == (_R1_IDLE_STATE | _R1_ILLEGAL_COMMAND): self.init_card_v1() else: raise OSError("couldn't determine SD card version") # get the number of sectors # CMD9: response R2 (R1 byte + 16-byte block read) if self.cmd(9, 0, 0, 0, False) != 0: raise OSError("no response from SD card") csd = bytearray(16) self.readinto(csd) if csd[0] & 0xC0 == 0x40: # CSD version 2.0 self.sectors = ((csd[8] << 8 | csd[9]) + 1) * 1024 elif csd[0] & 0xC0 == 0x00: # CSD version 1.0 (old, <=2GB) c_size = (csd[6] & 0b11) << 10 | csd[7] << 2 | csd[8] >> 6 c_size_mult = (csd[9] & 0b11) << 1 | csd[10] >> 7 read_bl_len = csd[5] & 0b1111 capacity = (c_size + 1) * (2 ** (c_size_mult + 2)) * (2**read_bl_len) self.sectors = capacity // 512 else: raise OSError("SD card CSD format not supported") # print('sectors', self.sectors) # CMD16: set block length to 512 bytes if self.cmd(16, 512, 0) != 0: raise OSError("can't set 512 block size") # set to high data rate now that it's initialised self.init_spi(baudrate) def init_card_v1(self): for i in range(_CMD_TIMEOUT): time.sleep_ms(50) self.cmd(55, 0, 0) if self.cmd(41, 0, 0) == 0: # SDSC card, uses byte addressing in read/write/erase commands self.cdv = 512 # print("[SDCard] v1 card") return raise OSError("timeout waiting for v1 card") def init_card_v2(self): for i in range(_CMD_TIMEOUT): time.sleep_ms(50) self.cmd(58, 0, 0, 4) self.cmd(55, 0, 0) if self.cmd(41, 0x40000000, 0) == 0: self.cmd(58, 0, 0, -4) # 4-byte response, negative means keep the first byte ocr = self.tokenbuf[0] # get first byte of response, which is OCR if not ocr & 0x40: # SDSC card, uses byte addressing in read/write/erase commands self.cdv = 512 else: # SDHC/SDXC card, uses block addressing in read/write/erase commands self.cdv = 1 # print("[SDCard] v2 card") return raise OSError("timeout waiting for v2 card") def cmd(self, cmd, arg, crc, final=0, release=True, skip1=False): self.cs(0) # create and send the command buf = self.cmdbuf buf[0] = 0x40 | cmd buf[1] = arg >> 24 buf[2] = arg >> 16 buf[3] = arg >> 8 buf[4] = arg buf[5] = crc self.spi.write(buf) if skip1: self.spi.readinto(self.tokenbuf, 0xFF) # wait for the response (response[7] == 0) for i in range(_CMD_TIMEOUT): self.spi.readinto(self.tokenbuf, 0xFF) response = self.tokenbuf[0] if not (response & 0x80): # this could be a big-endian integer that we are getting here # if final<0 then store the first byte to tokenbuf and discard the rest if final < 0: self.spi.readinto(self.tokenbuf, 0xFF) final = -1 - final for j in range(final): self.spi.write(b"\xff") if release: self.cs(1) self.spi.write(b"\xff") return response # timeout self.cs(1) self.spi.write(b"\xff") return -1 def readinto(self, buf): self.cs(0) # read until start byte (0xff) for i in range(_CMD_TIMEOUT): self.spi.readinto(self.tokenbuf, 0xFF) if self.tokenbuf[0] == _TOKEN_DATA: break time.sleep_ms(1) else: self.cs(1) raise OSError("timeout waiting for response") # read data mv = self.dummybuf_memoryview if len(buf) != len(mv): mv = mv[: len(buf)] self.spi.write_readinto(mv, buf) # read checksum self.spi.write(b"\xff") self.spi.write(b"\xff") self.cs(1) self.spi.write(b"\xff") def write(self, token, buf): self.cs(0) # send: start of block, data, checksum self.spi.read(1, token) self.spi.write(buf) self.spi.write(b"\xff") self.spi.write(b"\xff") # check the response if (self.spi.read(1, 0xFF)[0] & 0x1F) != 0x05: self.cs(1) self.spi.write(b"\xff") return # wait for write to finish while self.spi.read(1, 0xFF)[0] == 0: pass self.cs(1) self.spi.write(b"\xff") def write_token(self, token): self.cs(0) self.spi.read(1, token) self.spi.write(b"\xff") # wait for write to finish while self.spi.read(1, 0xFF)[0] == 0x00: pass self.cs(1) self.spi.write(b"\xff") def readblocks(self, block_num, buf): # workaround for shared bus, required for (at least) some Kingston # devices, ensure MOSI is high before starting transaction self.spi.write(b"\xff") nblocks = len(buf) // 512 assert nblocks and not len(buf) % 512, "Buffer length is invalid" if nblocks == 1: # CMD17: set read address for single block if self.cmd(17, block_num * self.cdv, 0, release=False) != 0: # release the card self.cs(1) raise OSError(5) # EIO # receive the data and release card self.readinto(buf) else: # CMD18: set read address for multiple blocks if self.cmd(18, block_num * self.cdv, 0, release=False) != 0: # release the card self.cs(1) raise OSError(5) # EIO offset = 0 mv = memoryview(buf) while nblocks: # receive the data and release card self.readinto(mv[offset : offset + 512]) offset += 512 nblocks -= 1 if self.cmd(12, 0, 0xFF, skip1=True): raise OSError(5) # EIO def writeblocks(self, block_num, buf): # workaround for shared bus, required for (at least) some Kingston # devices, ensure MOSI is high before starting transaction self.spi.write(b"\xff") nblocks, err = divmod(len(buf), 512) assert nblocks and not err, "Buffer length is invalid" if nblocks == 1: # CMD24: set write address for single block if self.cmd(24, block_num * self.cdv, 0) != 0: raise OSError(5) # EIO # send the data self.write(_TOKEN_DATA, buf) else: # CMD25: set write address for first block if self.cmd(25, block_num * self.cdv, 0) != 0: raise OSError(5) # EIO # send the data offset = 0 mv = memoryview(buf) while nblocks: self.write(_TOKEN_CMD25, mv[offset : offset + 512]) offset += 512 nblocks -= 1 self.write_token(_TOKEN_STOP_TRAN) def ioctl(self, op, arg): if op == 4: # get number of blocks return self.sectors if op == 5: # get block size in bytes return 512 ``` ### ymf825.py ```MicroPython:ymf825.py ############################################################################# # YMF825 synthesizer with Raspberry Pi PICO W. # # Hardware Information: # YMF825 bottom view # 1 2 3 4 5 6 7 8 9 # -+-+-+-+-+-+-+-+-+- # | S M M C G V R | # | S O I L N C S | # | S S K D C T | # | I O | # | Audio Jack # ---------------+--- # | # ---Amp # # PICO GPIO(pin) YMF825 name(pin) LED(n/a) # 5V (40) VCC (6) # GND (38) GND (5) # SPI1 MOSI 19(25) SPI MOSI (2) # SPI1 MISO 16(21) SPI MISO (3) # SPI1 CLK 18( 24) SPI CLK (4) # SPI1 CS 17(22) SS (1) # RESET 22(29) RESET (7) #n/a LED 28(34) Anode---1K--->|---Cathode---GND # # Copyright (c) by Shunsuke Ohira # 00.100 2023/08/05: Play Do-Re-Mi # # 20240326 Change Voice_Op_Orig & VoiceZ_Op_Edit # # 20241014 Note On Velocity 対応 ・・・ 固定値（0x54）から指定値（vol）対応へ # ############################################################################# from machine import SPI, UART, Pin import time import utime import uos from micropython import const import mojipy as moji ############################################################################### # 上記インポートファイルは、予め、Picoに書き込んでおくこと # Thonnyで 当該ファイルを開いて、Picoに書き込む。 # 直下に # mojipy.py : 文字処理用 ############################################################################### # YMF825 FM_OP_NUM = const(4) # number of FM operators OP_PARAM_NUM = const(10) # number of operater parameters TONE_NUM = const(16) # number of tones TONE_OP_NUM = const(4) # number of TONE operators TONE_PARAM_NUM = const(17) # number of tone parameters TONE_HEADER = const(16) # ToneID(1) + ToneName(15) ToneName = [None] * (TONE_NUM +1) ToneName[0] = 'GRAND_PIANO' ToneName[1] = 'E_PIANO' ToneName[2] = 'TENOR_SAX' ToneName[3] = 'PICK_BASS' ToneName[4] = 'TNKL_BELL' ToneName[5] = 'NEW_AGE_PD' ToneName[6] = 'BRIGHT_PIANO' ToneName[7] = 'VIBES' ToneName[8] = 'CHURCH_ORGAN' ToneName[9] = 'FLUTE' ToneName[10] = 'ROCK_ORGAN' ToneName[11] = 'NYLON_GUITER' ToneName[12] = 'SQUARE_LEAD' ToneName[13] = 'SAW_LEAD' ToneName[14] = 'HARPSICHORD' ToneName[15] = 'HARMONICA' ToneName[16] = 'No Tone' TONE_MENU_COL_NUM = const(2) # number of tones menu TONE_MENU_ROW_NUM = const(17) # number of tones menu # ToneMenuTable の生成 ToneMenuTable = [None] * TONE_MENU_ROW_NUM # 17 for i in range(TONE_MENU_ROW_NUM): ToneMenuTable[i] = [None] * TONE_MENU_COL_NUM # 2 ToneMenuTable[0][1] = ' Select Tone' for i in range(1, TONE_MENU_ROW_NUM): ToneMenuTable[i][0] = i -1 ToneMenuTable[i][1] = ToneName[i -1] TONE_TABLE_COL_NUM = const(2) # number of tones menu TONE_TABLE_ROW_NUM = const(17) # number of tones menu # ToneTavle の生成 ToneTable = [None] * TONE_TABLE_ROW_NUM # 17 for i in range(TONE_TABLE_ROW_NUM): ToneTable[i] = [None] * TONE_TABLE_COL_NUM # 2 ToneTable[0][1] = ' Select Tone' for i in range(1, TONE_TABLE_ROW_NUM): ToneTable[i][0] = i -1 # ToneTable[i][1] = 16 # 16:No Tone ToneTable[i][1] = 0 # 0:GRAND PIANO # Original Tone Data by YAMAHA # | 00 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | Tone_Com_Orig = [0x0b,0x0d,0x0d,0x0b,0x0d,0x0d,0x0b,0x0d, # | 08 | 09 | 10 | 11 | 12 | 13 | 14 | 15 | 0x0f,0x0d,0x17,0x15,0x15,0x15,0x0e,0x14] Tone_Op_Orig = [ # 00:GrandPiano [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x01,0x0f,0x07,0x00,0x06,0x0f,0x27,0x00,0x01,0x08], # op2 [0x07,0x0e,0x03,0x02,0x03,0x02,0x28,0x00,0x05,0x00], # op3 [0x00,0x0d,0x01,0x01,0x04,0x03,0x22,0x01,0x01,0x00], # op4 [0x06,0x0d,0x02,0x02,0x06,0x04,0x00,0x01,0x01,0x00] ], # 01:E.Piano [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x54,0x0f,0x04,0x05,0x0c,0x0b,0x23,0x44,0x07,0x12], # op2 [0x02,0x0f,0x02,0x01,0x08,0x0f,0x04,0x45,0x01,0x00], # op3 [0x25,0x0f,0x00,0x01,0x0b,0x01,0x12,0x44,0x01,0x00], # op4 [0x04,0x0f,0x02,0x01,0x07,0x0f,0x04,0x41,0x01,0x00] ], # 02:TenorSax [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x36,0x07,0x03,0x00,0x00,0x00,0x05,0x44,0x01,0x01], # op2 [0x00,0x07,0x02,0x00,0x09,0x00,0x0f,0x43,0x01,0x08], # op3 [0x36,0x07,0x03,0x00,0x00,0x00,0x08,0x44,0x01,0x09], # op4 [0x02,0x07,0x02,0x00,0x09,0x00,0x0d,0x43,0x01,0x00] ], # 03:PickBass [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x56,0x0f,0x07,0x02,0x03,0x01,0x13,0x44,0x01,0x00], # op2 [0x04,0x0c,0x0b,0x04,0x06,0x07,0x15,0x44,0x07,0x00], # op3 [0x06,0x0f,0x09,0x02,0x06,0x02,0x17,0x44,0x02,0x00], # op4 [0x04,0x0b,0x02,0x06,0x08,0x06,0x00,0x44,0x01,0x00] ], # 04:TnklBell [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x31,0x0f,0x06,0x03,0x04,0x05,0x10,0x44,0x0e,0x00], # op2 [0x02,0x0c,0x06,0x07,0x06,0x0e,0x0b,0x44,0x02,0x00], # op3 [0x00,0x0c,0x06,0x02,0x02,0x05,0x1e,0x44,0x77,0x01], # op4 [0x00,0x0f,0x05,0x04,0x05,0x0d,0x01,0x54,0x06,0x00] ], # 05:NewAgePd [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x54,0x0f,0x0f,0x03,0x03,0x00,0x26,0x44,0x07,0x01], # op2 [0x02,0x0f,0x07,0x04,0x04,0x00,0x0b,0x44,0x05,0x00], # op3 [0x62,0x06,0x01,0x00,0x01,0x00,0x18,0x03,0x71,0x01], # op4 [0x02,0x08,0x01,0x00,0x05,0x01,0x00,0x03,0x01,0x00] ], # 06:BrightPiano [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x06,0x0f,0x02,0x02,0x02,0x05,0x27,0x00,0x01,0x00], # op2 [0x02,0x0f,0x02,0x02,0x03,0x0f,0x1c,0x00,0x05,0x00], # op3 [0x06,0x0f,0x02,0x02,0x02,0x0d,0x19,0x01,0x01,0x00], # op4 [0x04,0x0f,0x02,0x01,0x05,0x04,0x0a,0x01,0x01,0x00] ], # 07:Vibes [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x00,0x0c,0x04,0x02,0x04,0x02,0x17,0x41,0x07,0x00], # op2 [0x06,0x0d,0x09,0x02,0x05,0x06,0x07,0x51,0x04,0x00], # op3 [0x04,0x0c,0x04,0x02,0x03,0x02,0x1e,0x51,0x08,0x00], # op4 [0x00,0x0d,0x02,0x03,0x04,0x0f,0x07,0x31,0x01,0x00] ], # 08:ChurchOrgan [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x02,0x09,0x0f,0x00,0x05,0x00,0x13,0x00,0x03,0x00], # op2 [0x00,0x0b,0x07,0x00,0x02,0x02,0x1d,0x00,0x07,0x00], # op3 [0x02,0x08,0x0f,0x00,0x05,0x00,0x04,0x00,0x01,0x00], # op4 [0x02,0x08,0x07,0x00,0x05,0x00,0x04,0x00,0x00,0x05] ], # 09:Flute [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x70,0x0d,0x0a,0x00,0x01,0x01,0x07,0x10,0x03,0x00], # op2 [0x00,0x07,0x08,0x00,0x0b,0x03,0x25,0x01,0x03,0x00], # op3 [0x70,0x0e,0x08,0x00,0x09,0x00,0x27,0x31,0x01,0x00], # op4 [0x00,0x06,0x05,0x00,0x0a,0x00,0x01,0x11,0x01,0x10] ], # 10:RockOrgan [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x41,0x0f,0x0f,0x00,0x0d,0x00,0x09,0x70,0x31,0x00], # op2 [0x01,0x0b,0x0f,0x00,0x0a,0x01,0x05,0x50,0x01,0x15], # op3 [0x00,0x0f,0x0f,0x00,0x0e,0x00,0x09,0x13,0x62,0x00], # op4 [0x00,0x0f,0x0f,0x00,0x0e,0x00,0x09,0x33,0x70,0x11] ], # 11:NylonGuiter [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x65,0x0e,0x01,0x01,0x04,0x08,0x15,0x00,0x01,0x00], # op2 [0x00,0x0f,0x03,0x03,0x07,0x0f,0x00,0x01,0x01,0x00], # op3 [0x04,0x0b,0x05,0x05,0x05,0x04,0x0e,0x00,0x03,0x00], # op4 [0x02,0x0d,0x04,0x04,0x09,0x0f,0x0d,0x03,0x01,0x00] ], # 12:SquareLead [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x03,0x0f,0x0f,0x00,0x07,0x04,0x2e,0x00,0x01,0x08], # op2 [0x02,0x0a,0x0f,0x00,0x0a,0x00,0x03,0x03,0x01,0x08], # op3 [0x13,0x0f,0x0f,0x00,0x02,0x03,0x26,0x10,0x02,0x08], # op4 [0x02,0x0a,0x0f,0x00,0x0a,0x00,0x03,0x01,0x01,0x08] ], # 13:SawLead [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x70,0x0f,0x00,0x00,0x07,0x00,0x1a,0x41,0x71,0x00], # op2 [0x00,0x0d,0x0f,0x00,0x07,0x00,0x0a,0x41,0x71,0x08], # op3 [0x71,0x0f,0x0f,0x00,0x03,0x00,0x14,0x41,0x01,0x1c], # op4 [0x00,0x0e,0x0f,0x00,0x08,0x00,0x0a,0x41,0x01,0x08] ], # 14:Harpsichord [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x45,0x0e,0x02,0x02,0x05,0x00,0x00,0x00,0x01,0x04], # op2 [0x07,0x0f,0x02,0x00,0x05,0x03,0x14,0x00,0x06,0x03], # op3 [0x06,0x0f,0x03,0x00,0x01,0x06,0x1c,0x00,0x07,0x04], # op4 [0x04,0x0e,0x02,0x02,0x07,0x0f,0x04,0x03,0x01,0x05] ], # 15:Harmonica [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x03,0x0f,0x0f,0x00,0x09,0x00,0x2c,0x07,0x0e,0x00], # op2 [0x00,0x0f,0x0f,0x00,0x08,0x00,0x29,0x11,0x0a,0x00], # op3 [0x00,0x0f,0x0f,0x00,0x08,0x00,0x24,0x03,0x01,0x00], # op4 [0x02,0x06,0x0f,0x00,0x08,0x00,0x03,0x01,0x02,0x00] ] ] # | 00 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | Tone_Com_Edit = [0x0b,0x0d,0x0d,0x0b,0x0d,0x0d,0x0b,0x0d, # | 08 | 09 | 10 | 11 | 12 | 13 | 14 | 15 | 0x0f,0x0d,0x17,0x15,0x15,0x15,0x0e,0x14] Tone_Op_Edit = [ # 00:GrandPiano [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x01,0x0f,0x07,0x00,0x06,0x0f,0x27,0x00,0x01,0x08], # op2 [0x07,0x0e,0x03,0x02,0x03,0x02,0x28,0x00,0x05,0x00], # op3 [0x00,0x0d,0x01,0x01,0x04,0x03,0x22,0x01,0x01,0x00], # op4 [0x06,0x0d,0x02,0x02,0x06,0x04,0x00,0x01,0x01,0x00] ], # 01:E.Piano [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x54,0x0f,0x04,0x05,0x0c,0x0b,0x23,0x44,0x07,0x12], # op2 [0x02,0x0f,0x02,0x01,0x08,0x0f,0x04,0x45,0x01,0x00], # op3 [0x25,0x0f,0x00,0x01,0x0b,0x01,0x12,0x44,0x01,0x00], # op4 [0x04,0x0f,0x02,0x01,0x07,0x0f,0x04,0x41,0x01,0x00] ], # 02:TenorSax [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x36,0x07,0x03,0x00,0x00,0x00,0x05,0x44,0x01,0x01], # op2 [0x00,0x07,0x02,0x00,0x09,0x00,0x0f,0x43,0x01,0x08], # op3 [0x36,0x07,0x03,0x00,0x00,0x00,0x08,0x44,0x01,0x09], # op4 [0x02,0x07,0x02,0x00,0x09,0x00,0x0d,0x43,0x01,0x00] ], # 03:PickBass [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x56,0x0f,0x07,0x02,0x03,0x01,0x13,0x44,0x01,0x00], # op2 [0x04,0x0c,0x0b,0x04,0x06,0x07,0x15,0x44,0x07,0x00], # op3 [0x06,0x0f,0x09,0x02,0x06,0x02,0x17,0x44,0x02,0x00], # op4 [0x04,0x0b,0x02,0x06,0x08,0x06,0x00,0x44,0x01,0x00] ], # 04:TnklBell [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x31,0x0f,0x06,0x03,0x04,0x05,0x10,0x44,0x0e,0x00], # op2 [0x02,0x0c,0x06,0x07,0x06,0x0e,0x0b,0x44,0x02,0x00], # op3 [0x00,0x0c,0x06,0x02,0x02,0x05,0x1e,0x44,0x77,0x01], # op4 [0x00,0x0f,0x05,0x04,0x05,0x0d,0x01,0x54,0x06,0x00] ], # 05:NewAgePd [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x54,0x0f,0x0f,0x03,0x03,0x00,0x26,0x44,0x07,0x01], # op2 [0x02,0x0f,0x07,0x04,0x04,0x00,0x0b,0x44,0x05,0x00], # op3 [0x62,0x06,0x01,0x00,0x01,0x00,0x18,0x03,0x71,0x01], # op4 [0x02,0x08,0x01,0x00,0x05,0x01,0x00,0x03,0x01,0x00] ], # 06:BrightPiano [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x06,0x0f,0x02,0x02,0x02,0x05,0x27,0x00,0x01,0x00], # op2 [0x02,0x0f,0x02,0x02,0x03,0x0f,0x1c,0x00,0x05,0x00], # op3 [0x06,0x0f,0x02,0x02,0x02,0x0d,0x19,0x01,0x01,0x00], # op4 [0x04,0x0f,0x02,0x01,0x05,0x04,0x0a,0x01,0x01,0x00] ], # 07:Vibes [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x00,0x0c,0x04,0x02,0x04,0x02,0x17,0x41,0x07,0x00], # op2 [0x06,0x0d,0x09,0x02,0x05,0x06,0x07,0x51,0x04,0x00], # op3 [0x04,0x0c,0x04,0x02,0x03,0x02,0x1e,0x51,0x08,0x00], # op4 [0x00,0x0d,0x02,0x03,0x04,0x0f,0x07,0x31,0x01,0x00] ], # 08:ChurchOrgan [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x02,0x09,0x0f,0x00,0x05,0x00,0x13,0x00,0x03,0x00], # op2 [0x00,0x0b,0x07,0x00,0x02,0x02,0x1d,0x00,0x07,0x00], # op3 [0x02,0x08,0x0f,0x00,0x05,0x00,0x04,0x00,0x01,0x00], # op4 [0x02,0x08,0x07,0x00,0x05,0x00,0x04,0x00,0x00,0x05] ], # 09:Flute [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x70,0x0d,0x0a,0x00,0x01,0x01,0x07,0x10,0x03,0x00], # op2 [0x00,0x07,0x08,0x00,0x0b,0x03,0x25,0x01,0x03,0x00], # op3 [0x70,0x0e,0x08,0x00,0x09,0x00,0x27,0x31,0x01,0x00], # op4 [0x00,0x06,0x05,0x00,0x0a,0x00,0x01,0x11,0x01,0x10] ], # 10:RockOrgan [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x41,0x0f,0x0f,0x00,0x0d,0x00,0x09,0x70,0x31,0x00], # op2 [0x01,0x0b,0x0f,0x00,0x0a,0x01,0x05,0x50,0x01,0x15], # op3 [0x00,0x0f,0x0f,0x00,0x0e,0x00,0x09,0x13,0x62,0x00], # op4 [0x00,0x0f,0x0f,0x00,0x0e,0x00,0x09,0x33,0x70,0x11] ], # 11:NylonGuiter [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x65,0x0e,0x01,0x01,0x04,0x08,0x15,0x00,0x01,0x00], # op2 [0x00,0x0f,0x03,0x03,0x07,0x0f,0x00,0x01,0x01,0x00], # op3 [0x04,0x0b,0x05,0x05,0x05,0x04,0x0e,0x00,0x03,0x00], # op4 [0x02,0x0d,0x04,0x04,0x09,0x0f,0x0d,0x03,0x01,0x00] ], # 12:SquareLead [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x03,0x0f,0x0f,0x00,0x07,0x04,0x2e,0x00,0x01,0x08], # op2 [0x02,0x0a,0x0f,0x00,0x0a,0x00,0x03,0x03,0x01,0x08], # op3 [0x13,0x0f,0x0f,0x00,0x02,0x03,0x26,0x10,0x02,0x08], # op4 [0x02,0x0a,0x0f,0x00,0x0a,0x00,0x03,0x01,0x01,0x08] ], # 13:SawLead [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x70,0x0f,0x00,0x00,0x07,0x00,0x1a,0x41,0x71,0x00], # op2 [0x00,0x0d,0x0f,0x00,0x07,0x00,0x0a,0x41,0x71,0x08], # op3 [0x71,0x0f,0x0f,0x00,0x03,0x00,0x14,0x41,0x01,0x1c], # op4 [0x00,0x0e,0x0f,0x00,0x08,0x00,0x0a,0x41,0x01,0x08] ], # 14:Harpsichord [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x45,0x0e,0x02,0x02,0x05,0x00,0x00,0x00,0x01,0x04], # op2 [0x07,0x0f,0x02,0x00,0x05,0x03,0x14,0x00,0x06,0x03], # op3 [0x06,0x0f,0x03,0x00,0x01,0x06,0x1c,0x00,0x07,0x04], # op4 [0x04,0x0e,0x02,0x02,0x07,0x0f,0x04,0x03,0x01,0x05] ], # 15:Harmonica [ # KC | AR | DR | SR | RR | SL | TL | VB | PT | WS # op1 [0x03,0x0f,0x0f,0x00,0x09,0x00,0x2c,0x07,0x0e,0x00], # op2 [0x00,0x0f,0x0f,0x00,0x08,0x00,0x29,0x11,0x0a,0x00], # op3 [0x00,0x0f,0x0f,0x00,0x08,0x00,0x24,0x03,0x01,0x00], # op4 [0x02,0x06,0x0f,0x00,0x08,0x00,0x03,0x01,0x02,0x00] ] ] # Tone Data 20240516 Change tone_data = bytearray(485) # 20240518 Add send_tone = [] rcv_tone = [] UART_TONE_NUM = const(42) # 整数の送信データサイズ UART_BUFF_SIZE = const(100) # UART ASCII の送信データサイズ send_buff = bytearray(UART_BUFF_SIZE) # ASCII ２文字のバッファ rcv_buff = bytearray(UART_BUFF_SIZE) # ASCII ２文字のバッファ # 20240619 Add uartT_buff = '' # uart ASCII ２文字の送信バッファ uartR_buff = '' # uart ASCII ２文字の受信バッファ # VOICE COMMON PARAMETER ROW s Number COM = const(0) BO = const(1) LFO = const(2) ALG = const(3) VOICE_COM_COL_NUM = const(4) # VOICE COMMON PARAMETER COLUMON s Number CM0 = const(0) # Oparator Name CM1 = const(1) # Edit CM2 = const(2) # Orig CM3 = const(3) # Max VOICE_COM_ROW_NUM = const(4) # 20240326 Change # VOICE OPTIONAL PARAMETER ROW s Number OPT = const(0) SR = const(1) XOF = const(2) KSR = const(3) RR = const(4) DR = const(5) AR = const(6) SL = const(7) TL = const(8) KSL = const(9) DAM = const(10) EAM = const(11) DVB = const(12) EVB = const(13) MUL = const(14) DT = const(15) WS = const(16) FB = const(17) VOICE_OP_ROW_NUM = const(18) # VOICE OPTIONAL PARAMETER COLUMN s Number OP0 = const(0) # Oparator Name OP1 = const(1) # Edit 1 OP2 = const(2) # Edit 2 OP3 = const(3) # Edit 3 OP4 = const(4) # Edit 4 OP5 = const(5) # Orig 1 OP6 = const(6) # Orig 2 OP7 = const(7) # Orig 3 OP8 = const(8) # Orig 4 OP9 = const(9) # Max VOICE_OP_COL_NUM = const(10) # 編集用テーブルの生成 # Voice_Com_Edit テーブルの生成 Voice_Com_Edit = [None] * VOICE_COM_ROW_NUM # 4 for i in range(VOICE_COM_ROW_NUM): Voice_Com_Edit[i] = [None] * VOICE_COM_COL_NUM # 4 # VOICE COMMON PARAMETER TABLE ROW s NAME # Voice_Com_Edit[COM][CM0] = 'Common' Voice_Com_Edit[COM][CM1] = 'Edt' Voice_Com_Edit[COM][CM2] = 'Org' Voice_Com_Edit[COM][CM3] = 'Max' # VOICE COMMON PARAMETER ROW s NAME VoiceComName = [None] * VOICE_COM_ROW_NUM VoiceComName[COM] = 'Common' VoiceComName[BO] = 'BO' VoiceComName[LFO] = 'LFO' VoiceComName[ALG] = 'ALG' # VOICE COMMON PARAMETER TABLE COLUMN s NAME for i in range(VOICE_COM_ROW_NUM): # i : 0 - 3 Voice_Com_Edit[i][CM0] = VoiceComName[i] # Voice_Op_Edit テーブルの生成 Voice_Op_Edit = [None] * VOICE_OP_ROW_NUM # 18 for i in range(VOICE_OP_ROW_NUM): Voice_Op_Edit[i] = [None] * VOICE_OP_COL_NUM # 10 # VOICE OPARATOR PARAMETER TABLE ROW s NAME # Voice_Op_Edit[OPT][OP0] = 'Optional' Voice_Op_Edit[OPT][OP1] = 'e1' Voice_Op_Edit[OPT][OP2] = 'e2' Voice_Op_Edit[OPT][OP3] = 'e3' Voice_Op_Edit[OPT][OP4] = 'e4' Voice_Op_Edit[OPT][OP5] = 'o1' Voice_Op_Edit[OPT][OP6] = 'o2' Voice_Op_Edit[OPT][OP7] = 'o3' Voice_Op_Edit[OPT][OP8] = 'o4' Voice_Op_Edit[OPT][OP9] = 'Mx' # VOICE OPARATOR PARAMETER COLUMN s NAME VoiceOpName = [None] * VOICE_OP_ROW_NUM VoiceOpName[OPT] = 'Operator' VoiceOpName[SR] = 'SR' VoiceOpName[XOF] = 'XOF' VoiceOpName[KSR] = 'KSR' VoiceOpName[RR] = 'RR' VoiceOpName[DR] = 'DR' VoiceOpName[AR] = 'AR' VoiceOpName[SL] = 'SL' VoiceOpName[TL] = 'TL' VoiceOpName[KSL] = 'KSL' VoiceOpName[DAM] = 'DAM' VoiceOpName[EAM] = 'EAM' VoiceOpName[DVB] = 'DVB' VoiceOpName[EVB] = 'EVB' VoiceOpName[MUL] = 'MUL' VoiceOpName[DT] = 'DT' VoiceOpName[WS] = 'WS' VoiceOpName[FB] = 'FB' # VOICE OPTIONAL PARAMETER TABLE ROW s NAME for i in range(VOICE_OP_ROW_NUM): # i : 0 - 18 Voice_Op_Edit[i][OP0] = VoiceOpName[i] # Common BO, LFO, ALG の最大値 Voice_Com_Max = [3, 3, 7] # Common SR, XOF, KSR, RR, DR, AR, SL, TL, KSL, DAM, EAM, DVB, EVB, MUL, DT,WS, FB の最大値 Voice_Op_Max = [15, 1, 1, 15, 15, 15, 15, 63, 3, 3, 1, 3, 1, 15, 7, 31, 7] # Voice_Com_Edit TABLE s Max # VOICE COMMON PARAMETER TABLE s Max for i in range(1, VOICE_COM_ROW_NUM): # i : 1 - 3 Voice_Com_Edit[i][CM3] = Voice_Com_Max[i -1] # Voice_Op_Edit TABLE s Max # VOICE OPTIONAL PARAMETER TABLE s Max for i in range(1, VOICE_OP_ROW_NUM): # i : 1 - 17 Voice_Op_Edit[i][OP9] = Voice_Op_Max[i -1] # MIDI GM to YMF825 Tone Change # テーブル（辞書） # 2025/10/01 SyntaxError 発生 # 01:06, # 02：Bright Acostic Piano：06：Bright Piano では # Traceback (most recent call last): # File "<stdin>", line 670 # SyntaxError: invalid syntax for integer with base 0 # 余分な 0 があるとダメになったようだ。 # exGmYmf825 = {0:0, # ピアノ系 1:6, # 02：Bright Acostic Piano：06：Bright Piano 2:1, # 03：Electric Grand Piano：01：E.Piano 3:1, # 04：Honky-Tonk Piano：01：E.Piano 4:1, # 05：Electric Piano 1：01：E.Piano 5:1, # 06：Electric Piano 2：01：E.Piano 6:0, 7:0, # クロマチック・パーカッション系：04：TiklBell 8:4, 9:4, 10:4, 11:7, # 12：Vibraphone：ヴィヴラフォン：大型鉄琴：07：Vibes 12:4, 13:4, 14:4, 15:4, 16:4, 17:4, # オルガン系 18:10, 19:8, # 20：Church Organ：パイプ・オルガン：08：Church Organ 20:10, 21:15, # 22：Accordion：アコーディオン：15：Harmonica 22:10, 23:10, # ギター系 24:11, # 25：Acostic Guitar (nylon)：11：NulonGuiter 25:11, 26:11, 27:11, 28:11, 29:11, 30:11, 31:11,\ # ベース系 32:3, # 33：Acosic Bass 通常のアコースティック：03：PickBass 33:3, # 34：Electric Bass (finger)：03：PickBass 34:3, # 35：Electric Bass (pick)：03：PickBass 35:3, 36:3, 37:3, 38:3, 39:3, # ストリングス系 40:12, # 41：Violin ヴァイオリン：12：SpuareLead 41:14, 42:14, 43:14, 44:14, 45:14, 46:14, # 47：Orchestral Harp：ハープ：14：Harrpsichord 47:14, # アンサンブル系 48:10, # 49：String Ensamble-1：ストリングス・アンサンブル：10：RockOrgan 49:10, # 50：String Ensamble 2：ストリンクス・アンサンブル：10：RockOrgan 50:5, # 51：Synth Strings 1：05：NewAgePd 51:5, # 52：Synth Strings 2：05：NewAgePd 52:5, 53:5, 54:5, 55:5, # ブラス系 56:0, 57:0, 58:0, 59:0, 60:0, 61:0, 62:0, 63:0, # リード系 64:2, 65:2, 66:2, 67:2, 68:2, 69:2, 70:2, 71:2, # 72：Clarinet：クラリネット：02：TenorSax # パイプ系 72:9, 73:9, # 74：Flute：フルート：09：Flute 74:13, # 75：Recorder：リコーダー：13：SawLead 75:13, 76:13, 77:13, 78:13, 79:13, # シンセ・リード系 80:0, 81:0, 82:0, 83:0, 84:0, 85:0, 86:0, 87:0, # シンセ・パッド系 88:0, 89:0, 90:0, 91:0, 92:0, 93:0, 94:0, 95:0, 96:0, # シンセ・エフェクト系 97:0, 98:0, 99:0,100:0,101:0,102:0,103:0, # エスニック系 104:0,105:0,106:0,107:0,108:0,109:0,110:0,111:0, # パーカッシヴ系 112:0,113:0,114:0,115:0,116:0,117:0,118:0,119:0, # 効果音 120:0,121:0,122:0,123:0,124:0,125:0,126:0,127:0} GmName = [None] * (128 +1) GmName[0] = 'MIDI GM Tone Name' # ピアノ系 GmName[1] = 'Acostic Grand Piano' GmName[2] = 'Bright Acostic Piano' GmName[3] = 'Electric Grand Piano' GmName[4] = 'Honky-Tonk Piano' GmName[5] = 'Electric Piano 1' GmName[6] = 'Electric Piano 2' GmName[7] = 'Harpsicord' GmName[8] = 'Clavi' # クロマチック・パーカッション系 GmName[9] = 'Celesta' GmName[10] = 'Glockenspiel' GmName[11] = 'Music Box' GmName[12] = 'Vibraphone' GmName[13] = 'Marimba' GmName[14] = 'Xylophone' GmName[15] = 'Tubular Bells' GmName[16] = 'Dulcimer' # オルガン系 GmName[17] = 'Drawber Organ' GmName[18] = 'Percussive Organ' GmName[19] = 'Rock Organ' GmName[20] = 'Church Organ' GmName[21] = 'Reed Organ' GmName[22] = 'Accordion' GmName[23] = 'Harmonica' GmName[24] = 'Tango Accordion' # ギター系 GmName[25] = 'Acostic Guitar (nylon)' GmName[26] = 'Acostic Guitar (steel)' GmName[27] = 'Electric Guitar (jazz)' GmName[28] = 'Electric Guitar (clean)' GmName[29] = 'Electric Guitar (muted)' GmName[30] = 'Overdriven Guitar' GmName[31] = 'Distortion Guitar' GmName[32] = 'Guitar Harmonics' # ベース系 GmName[33] = 'Acosic Bass' GmName[34] = 'Electric Bass (finger)' GmName[35] = 'Electric Bass (pick)' GmName[36] = 'Fretless Bass' GmName[37] = 'Slap Bass 1' GmName[38] = 'Slap Bass 2' GmName[39] = 'Synth Bass 1' GmName[40] = 'Synth Bass 2' # ストリングス系 GmName[41] = 'Violin' GmName[42] = 'Viola' GmName[43] = 'Cello' GmName[44] = 'Contrabass' GmName[45] = 'Tremoro Strings' GmName[46] = 'Pizzicato Strings' GmName[47] = 'Orchestral Harp' GmName[48] = 'Timpani' # アンサンブル系 GmName[49] = 'String Ensamble 1' GmName[50] = 'String Ensamble 2' GmName[51] = 'Synth Strings 1' GmName[52] = 'Synth Strings 2' GmName[53] = 'Choir Aahs' GmName[54] = 'Voice Oohs' GmName[55] = 'Synth Voice' GmName[56] = 'Orchestra Hit' # ブラス系 GmName[57] = 'Trumpet' GmName[58] = 'Trombone' GmName[59] = 'Tuba' GmName[60] = 'Muted Trumpet' GmName[61] = 'French Horn' GmName[62] = 'Brass Section' GmName[63] = 'Synth Brass 1' GmName[64] = 'Synth Brass 2' # リード系 GmName[65] = 'Soprano Sax' GmName[66] = 'Alto Sax' GmName[67] = 'Tenor Sax' GmName[68] = 'Baritone Sax' GmName[69] = 'Oboe' GmName[70] = 'English Horn' GmName[71] = 'Bassoon' GmName[72] = 'Clarinet' # パイプ系 GmName[73] = 'Piccolo' GmName[74] = 'Flute' GmName[75] = 'Recorder' GmName[76] = 'Pan Flute' GmName[77] = 'Bottle Blow' GmName[78] = 'Shakuhachi' GmName[79] = 'Whistle' GmName[80] = 'Ocarina' # シンセ・リード系 GmName[81] = 'Lead 1 (square)' GmName[82] = 'Lead 2 (sawtooth)' GmName[83] = 'Lead 3 (caliope)' GmName[84] = 'Lead 4 (chiff)' GmName[85] = 'Lead 5 (charang)' GmName[86] = 'Lead 6 (voice)' GmName[87] = 'Lead 7 (fifth)' GmName[88] = 'Lead 8 (bass+lead)' # シンセ・パッド系 GmName[89] = 'Pad 1 (new age)' GmName[90] = 'Pad 2 (warm)' GmName[91] = 'Pad 3 (polysynth)' GmName[92] = 'Pad 4 (choir)' GmName[93] = 'Pad 5 (bowed)' GmName[94] = 'Pad 6 (metalic)' GmName[95] = 'Pad 7 (halo)' GmName[96] = 'Pad 8 (sweep)' # シンセ・エフェクト系 GmName[97] = 'FX (rain)' GmName[98] = 'FX (soundtrack)' GmName[99] = 'FX (crystal)' GmName[100] = 'FX (atmosphere)' GmName[101] = 'FX (brightness)' GmName[102] = 'FX (goblins)' GmName[103] = 'FX (echoes)' GmName[104] = 'FX (sci-fi)' # エスニック系 GmName[105] = 'Sitar' GmName[106] = 'Banjo' GmName[107] = 'Shamisen' GmName[108] = 'Koto' GmName[109] = 'Kalimba' GmName[110] = 'Bagpipe' GmName[111] = 'Fiddle' GmName[112] = 'Shanai' # パーカッシヴ系 GmName[113] = 'Tinkle Bell' GmName[114] = 'Agogo' GmName[115] = 'Steel Drums' GmName[116] = 'Woodblock' GmName[117] = 'Taiko Drum' GmName[118] = 'Melodic Tom' GmName[119] = 'Synth Drum' GmName[120] = 'Reverse Cymbal' # 効果音 GmName[121] = 'Guitar Fret Noise' GmName[122] = 'Breath Noise' GmName[123] = 'Seashore' GmName[124] = 'Bird Tweet' GmName[125] = 'Telephone Ring' GmName[126] = 'Helicopter' GmName[127] = 'Applause' GmName[128] = 'Gun Shot' # YMF825 # key name KEY_C = const(0) KEY_C_SHARP = const(1) KEY_D = const(2) KEY_D_SHARP = const(3) KEY_E = const(4) KEY_F = const(5) KEY_F_SHARP = const(6) KEY_G = const(7) KEY_G_SHARP = const(8) KEY_A = const(9) KEY_A_SHARP = const(10) KEY_B = const(11) # I/O voltage IOVDD_5V = const(0) IOVDD_3V3 = const(1) # number of channels CH_MAX = const(16) # FNUM table # C C# D D# E F F# G G# A A# B FNUM = [357, 378, 401, 425, 450, 477, 505, 535, 567, 601, 637, 674] FNUM_MAX = 12 # FNUM table (high byte) calcurated in SimpleYMF825::begin() uint8_t FNUMH[12]; FNUMH = [None] * FNUM_MAX # FNUM table (low byte) calcurated in SimpleYMF825::begin() uint8_t FNUML[12]; # uint8_t FNUML[12]; FNUML = [None] * FNUM_MAX # init_fnum() で FNUMH FNUML を定義する for i in range(FNUM_MAX): FNUMH[i] = (FNUM[i] & 0x0380) >> 4 FNUML[i] = (FNUM[i] & 0x007F) # PicoMain では、使用しない ・・・ ここから # SPI SPI_CH = const(0) SPI_MAX_SPEED_HZ = const(1000000) #GPIO assignment # Pin No. SPIPORT_MOSI = const(19) # pin25 SPIPORT_MISO = const(16) # pin21 SPIPORT_CLK = const(18) # pin24 SPIPORT_CE = const(17) # pin22 YMF825_RESET = const(22) # pin29 GPIO_LED = const(28) # pin34 # N/A # SPI0 YMF825 spi_cs = Pin(SPIPORT_CE, Pin.OUT) spi0 = SPI(SPI_CH, sck=Pin(SPIPORT_CLK), mosi=Pin(SPIPORT_MOSI), miso=Pin(SPIPORT_MISO), baudrate=SPI_MAX_SPEED_HZ, firstbit=SPI.MSB, polarity=0, phase=0) print('spi0 YMF825 in YMF825py = ', spi0) print() # YMF825 RESET pin YMF825_reset = Pin(YMF825_RESET, Pin.OUT) # LED (CURRENTLY NOT AVAILABLE) led_indicator = Pin(GPIO_LED, Pin.OUT) # PicoMain では、使用しない ・・・ ここまで # 20240501 Add # UASRT 設定 UART_BAUD = 115200 # 20240517 Change # uart = UART(1, UART_BAUD, bits=8, parity=None, stop=1, tx=Pin(4), rx=Pin(5)) # # uart = UART(1, UART_BAUD, bits=8, parity=None, stop=1, tx=Pin(4), rx=Pin(5), \ # timeout=500, timeout_char=500) # # 20240810 Change uart = UART(1, UART_BAUD, bits=8, parity=None, stop=1, tx=Pin(4), rx=Pin(5), \ timeout=50, timeout_char=50) #LED indicator # onoff:: True:turn on, False: turn off def led_turn(onoff): led_indicator.value(1 if onoff else 0) #Wait timer # msec:: Waite time in milli-seconds def delay(msec): time.sleep(msec/1000) #Set SPI Slave Select Pin (CE0) # PicoMain では、使用しない。 # pinv:: GPIO.HIGH: not-select, GPIO.LOW: select def chip_select(sel): spi_cs.value(0 if sel else 1) ################################################################# # 20240316 Add & Change in use # PicoMain では、使用しない。 # SPI write (multi bytes) def spi_write_multi(addr, multi_data): data_array = bytearray([addr]) data_array += multi_data chip_select(True) spi0.write(data_array) chip_select(False) # 20240316 Add in use # PicoMain では、使用しない。 # SPI write (single byte) def spi_write_single(addr, single_data): data_array = bytearray([addr, single_data]) chip_select(True) spi0.write(data_array) chip_select(False) ################################################################# #Set Chanel # PicoMain では、使用しない。 def set_chanel(): spi_write_single(0x0F,0x30) spi_write_single(0x10,0x71) spi_write_single(0x11,0x00) spi_write_single(0x12,0x08) spi_write_single(0x13,0x00) # 20240314 ADD in use # Set Mater Volume # vol: volume (0...63) # 1...63; -50dB... +12dB def set_MasterVolume(vol): spi_write_single(25,vol << 2) # 20240315 Add in use # PicoMain では、使用しない。 # ch:0-15 octave: vol: def keyon4(ch, octave, key, vol): global FNUMH global FNUML # global sund_param spi_write_single(11,ch & 0x0F) spi_write_single(12,vol & 0x7F) spi_write_single(13,FNUMH[key] | (octave - 1)) spi_write_single(14,FNUML[key]) spi_write_single(15,0x40 | 0) # Last 0:tone led_turn(True) # 20240315 Add in use # PicoMain では、使用しない。 # ch:0-15 octave: vol: def keyon5(ch, octave, key, vol, tone): global FNUMH global FNUML # global sund_param spi_write_single(11,ch & 0x0F) spi_write_single(12,vol & 0x7F) spi_write_single(13,FNUMH[key] | (octave - 1)) spi_write_single(14,FNUML[key]) spi_write_single(15,0x40 | tone & 0x0F) led_turn(True) # 20240315 Add in use # PicoMain では、使用しない。 def keyoff(ch): spi_write_single(11, ch & 0x0F) spi_write_single(0x0F, 0) led_turn(False) # 20240622 Add in use # PicoMain では、使用しない。 # tone は、ToneTableを参照し、16以上ならば何もしない def note_on(ch, octave, key, vol): global FNUMH global FNUML global Tonetable # ToneTable の値が 16未満なら if ToneTable[(ch & 0x0F) +1][1] <16: spi_write_single(11,ch & 0x0F) spi_write_single(12,vol & 0x7F) spi_write_single(13,FNUMH[key] | (octave - 1)) spi_write_single(14,FNUML[key]) spi_write_single(15,0x40 | ToneTable[(ch & 0x0F) +1][1]) led_turn(True) # 20240705 Add in use # PicoMain では、使用しない。 # tone は、１つを指定する。 def note_onMonoTone(ch, octave, key, vol, tone): global FNUMH global FNUML global Tonetable # ToneTable の値が 16未満なら if ToneTable[(ch & 0x0F) +1][1] <16: spi_write_single(11,ch & 0x0F) spi_write_single(12,vol & 0x7F) spi_write_single(13,FNUMH[key] | (octave - 1)) spi_write_single(14,FNUML[key]) spi_write_single(15,0x40 | tone & 0x0F) led_turn(True) # 20240622 Add in use # PicoMain では、使用しない。 def note_off(ch): spi_write_single(11, ch & 0x0F) spi_write_single(0x0F, 0) led_turn(False) ################################################################# # 20240501 Add def uart_write_multi(multi_data): uart.write(multi_data) # 20240618 Add def uart_read_multi(): global rcv_buff rcv_size = uart.readinto(rcv_buff) return rcv_size # 20240701 Add def uart_blank_read(): while uart.any() > 0: try: data_rx = uart.read(1) except UnicodeError: print('uart_blank_read() UnicodeError') except: print('uart_blank_read() Error') ################################################################# # 20240518 Add def uartOutToneData(): global send_buff print("Write tone data out to UART") uart_write_multi(send_buff) # 20240619 Add def uartOutToneTable(): global uartT_buff print("Write Tone Table out to UART") uart_write_multi(uartT_buff) # 20240518 Add # 20240619 Change ==> headerID が、0：ToneData、1：ToneTable、両方に対応 def uartInTone(): global rcv_buff # ASCII ２文字リスト global rcv_tone # 整数リスト print("Read tone data in from UART") rcv_size = uart_read_multi() if rcv_size == None: # 受信データなし print() print('rcv_size = None') # rcv_size, headerID, tone_name return None, None, None else: # 受信データあり # DEBUG print print('rcv_size = ', rcv_size) # print(rcv_buff) headerID = chr(rcv_buff[0]) if headerID == '0': tone_name = rcv_buff[1:TONE_HEADER].decode('utf-8') # tone_name print('Recive Data = ', tone_name) # ２文字の ASCIIコード（0-9 A-F）を１byteの整数に変換する。 rcv_tone = [] for i in range(UART_TONE_NUM): # 42 rcv_tone.append(moji.asc2int(chr(rcv_buff[TONE_HEADER + i *2]) \ + chr(rcv_buff[TONE_HEADER + i *2 +1]))) # DEBUG print print('rcv_tone = ', rcv_tone) return rcv_size, headerID, tone_name elif headerID == '1': tone_name = rcv_buff[1:TONE_HEADER].decode('utf-8') # 'Tone Table' print('Recive Data = ', tone_name) # ２文字の ASCIIコード（0-9 A-F）を１byteの整数に変換する。 rcv_tone = [] for i in range(TONE_TABLE_ROW_NUM -1): # 0-15 : 16 rcv_tone.append(moji.asc2int(chr(rcv_buff[TONE_HEADER + i *2]) \ + chr(rcv_buff[TONE_HEADER + i *2 +1]))) # DEBUG print print('ToneTable = ', rcv_tone) return rcv_size, headerID, tone_name elif headerID == '%': # PrintDFP command print('rcv_buff = ', rcv_buff) PrintDFPcommand = rcv_buff[:rcv_size] # DEBUG print print('PrintDFPcommand = ', PrintDFPcommand) # return rcv_size, headerID, tone_name return rcv_size, headerID, PrintDFPcommand ################################################################# # 20240518 Add # tone_num で指定された Tone\Com_edit および Tone_Op_Edit の情報を # UART送信で使用する ASCIIコードの２文字に変換する。 def takeOutToneData(num): tone_num = num & 0x0F # 念の為 0-15 に限定 global send_tone global send_buff global Tone_Com_Edit global Tone_Op_Edit send_buff[0] = ord('0') # [0]:ZERO:ToneID # ToneName send_buff[1:TONE_HEADER] = bytes(moji.strFixL_n(ToneName[tone_num], TONE_HEADER -1), 'utf8') send_tone = [] # 整数 send_tone.append(tone_num) send_tone.append(Tone_Com_Edit[tone_num]) for i in range(FM_OP_NUM): # 4 for j in range(OP_PARAM_NUM): # 10 send_tone.append(Tone_Op_Edit[tone_num][i][j]) # DEBUG print # print('send ToneData = ', send_tone) # １byte の整数を ASCIIコード（0-9 A-F）の２文字に変換する。 for i in range(UART_TONE_NUM): # 42 (asc_H, asc_L) = moji.int2asc2(send_tone[i]) send_buff[TONE_HEADER + i *2] = ord(asc_H) send_buff[TONE_HEADER + i *2 +1] = ord(asc_L) ################################################################# # 20251004 Add 20251014:edit_num, save_num に分ける理由は何だったか？ # editTN で指定された Tone_Com_edit および Tone_Op_Edit の情報を # UART送信で使用する ASCIIコードの２文字に変換する。 # トーン番号を saveTN にする。 def takeOutToneData2(edit_num, save_num): edit_num = edit_num & 0x0F # 念の為 0-15 に限定 save_num = save_num & 0x0F global send_tone global send_buff global Tone_Com_Edit global Tone_Op_Edit send_buff[0] = ord('0') # [0]:ZERO:ToneID # ToneName send_buff[1:TONE_HEADER] = bytes(moji.strFixL_n(ToneName[edit_num], TONE_HEADER -1), 'utf8') send_tone = [] # 整数 send_tone.append(save_num) # 20251004 Change edit_num ---> save_num send_tone.append(Tone_Com_Edit[edit_num]) for i in range(FM_OP_NUM): # 4 for j in range(OP_PARAM_NUM): # 10 send_tone.append(Tone_Op_Edit[edit_num][i][j]) # DEBUG print # print('send ToneData = ', send_tone) # １byte の整数を ASCIIコード（0-9 A-F）の２文字に変換する。 for i in range(UART_TONE_NUM): # 42 (asc_H, asc_L) = moji.int2asc2(send_tone[i]) send_buff[TONE_HEADER + i *2] = ord(asc_H) send_buff[TONE_HEADER + i *2 +1] = ord(asc_L) ################################################################# # 20240619 Add # Tone Table の情報を UART送信で使用する ASCIIコードの２文字に変換する。 def takeOutToneTable(): global ToneTable global send_tone global send_buff global uartT_buff send_buff[0] = ord('1') # [1]:ONE:Tone Table # Tone Table send_buff[1:TONE_HEADER] = bytes(moji.strFixL_n('Tone Table', TONE_HEADER -1), 'utf8') # ToneTable の中身だけ抽出 ・・・ ch 0-15 に対応する ToneNo 0-16 16:NoTone send_tone = [] # 整数リスト for i in range(1, TONE_TABLE_ROW_NUM): # 1-17 : 16 send_tone.append(ToneTable[i][1]) # DEBUG print # print('send ToneTable = ', send_tone) # １byte の整数を ASCIIコード（0-9 A-F）の２文字に変換する。 for i in range(TONE_TABLE_ROW_NUM -1): # 0-15 : 16 (asc_H, asc_L) = moji.int2asc2(send_tone[i]) send_buff[TONE_HEADER + i *2] = ord(asc_H) send_buff[TONE_HEADER + i *2 +1] = ord(asc_L) # TONE_HEADER + (TONE_TABLE_ROW_NUM) *2) = 48 bytes uartT_buff = send_buff[:(TONE_HEADER + (TONE_TABLE_ROW_NUM -1) *2)] ################################################################# # 20240518 Add # 受信した rcv_tone のデータを tone_num で指定された番号の # Tone_Com_edit および Tone_Op_Edit に格納する。 def takeInToneData(): global rcv_tone # 整数リスト global Tone_Com_Edit global Tone_Op_Edit if len(rcv_tone) > 0: tone_num = rcv_tone[0] & 0x0F # 念の為、0-15 に限定 Tone_Com_Edit[tone_num] = rcv_tone[1] # rcv_tone は、２文字の ASCIIコード（0-9 A-F）から１byteの整数に変換したリスト # rcv_tone データを Tone_Op_Edit に格納 for i in range(FM_OP_NUM): # 4 for j in range(OP_PARAM_NUM): # 10 Tone_Op_Edit[tone_num][i][j] = rcv_tone[2 + i *OP_PARAM_NUM + j] else: tone_num = None return tone_num ################################################################# # 20240620 Add # 受信した rcv_tone のデータを ToneTable に格納する。 def takeInToneTable(): global rcv_tone # 整数リスト global ToneTable if len(rcv_tone) > 0: if len(rcv_tone) == (TONE_TABLE_ROW_NUM -1): # 16 # rcv_tone は、２文字の ASCIIコード（0-9 A-F）から１byteの整数に変換したリスト # rcv_tone データを ToneTable に格納 for i in range(1, TONE_TABLE_ROW_NUM): # 1-17 : 16 ToneTable[i][1] = rcv_tone[i -1] # rcv_tone[i] 0-16 print('ToneTable =', ToneTable) else: print('rcv_tone size is not 16') print('ToneTable size is 16') else: print('rcv_tone is None') ################################################################# # 20240318 Add in use # YMF825 に tone_dataを設定する # PicoMain では、使用しない。 def init_tone(): global tone_data global Tone_Com_Edit global Tone_Op_Edit global ToneName # tone parameter data size COMMON_PARAM_SIZE = 2 OP_PARAM_SIZE = 7 TONE_PARAM_SIZE = COMMON_PARAM_SIZE + FM_OP_NUM * OP_PARAM_SIZE; MESSAGE_SIZE = TONE_PARAM_SIZE * TONE_NUM + 1 + 4 # 485 # print() # print("YMF825 Tone Parameter Setting Data") # header tone_data[0] = 0x80 + TONE_NUM # print(f"Header = {tone_data[0]:4}") # register data for i in range(TONE_NUM): # print() # print(f'Voice Number = {i} : {ToneName[i]}') # common parameter 1 tone_data[i* TONE_PARAM_SIZE +1] = (Tone_Com_Edit[i] & 0x60) >> 5 # print(f"common parameter 1 = {tone_data[i* TONE_PARAM_SIZE +1]:4}") # common parameter 2 tone_data[i* TONE_PARAM_SIZE +2] = ((Tone_Com_Edit[i] & 0x18) << 3) | (Tone_Com_Edit[i] & 0x07) # print(f"common parameter 2 = {tone_data[i* TONE_PARAM_SIZE +2]:4}") # operator parameter 7 x 4 for j in range(FM_OP_NUM): # print(f"operator parameter [{j}] = ", end = "") tone_data[i* TONE_PARAM_SIZE + j* OP_PARAM_SIZE +3] = \ (Tone_Op_Edit[i][j][3] << 4) | \ (Tone_Op_Edit[i][j][0] & 0x08) | \ ((Tone_Op_Edit[i][j][0] & 0x04) >> 2) # print(f"{tone_data[i* TONE_PARAM_SIZE + j* OP_PARAM_SIZE +3]:4},", end = "") tone_data[i* TONE_PARAM_SIZE + j* OP_PARAM_SIZE +4] = \ (Tone_Op_Edit[i][j][4] << 4) | Tone_Op_Edit[i][j][2] # print(f"{tone_data[i* TONE_PARAM_SIZE + j* OP_PARAM_SIZE +4]:4},", end = "") tone_data[i* TONE_PARAM_SIZE + j* OP_PARAM_SIZE +5] = \ (Tone_Op_Edit[i][j][1] << 4) | Tone_Op_Edit[i][j][5] # print(f"{tone_data[i* TONE_PARAM_SIZE + j* OP_PARAM_SIZE +5]:4},", end = "") tone_data[i* TONE_PARAM_SIZE + j* OP_PARAM_SIZE +6] = \ (Tone_Op_Edit[i][j][6] << 2) | (Tone_Op_Edit[i][j][0] & 0x03) # print(f"{tone_data[i* TONE_PARAM_SIZE + j* OP_PARAM_SIZE +6]:4},", end = "") tone_data[i* TONE_PARAM_SIZE + j* OP_PARAM_SIZE +7] = \ Tone_Op_Edit[i][j][7] # print(f"{tone_data[i* TONE_PARAM_SIZE + j* OP_PARAM_SIZE +7]:4},", end = "") tone_data[i* TONE_PARAM_SIZE + j* OP_PARAM_SIZE +8] = \ ((Tone_Op_Edit[i][j][8] & 0x0f) << 4) | \ ((Tone_Op_Edit[i][j][8] & 0xf0) >> 4) # print(f"{tone_data[i* TONE_PARAM_SIZE + j* OP_PARAM_SIZE +8]:4},", end = "") tone_data[i* TONE_PARAM_SIZE + j* OP_PARAM_SIZE +9] = \ (Tone_Op_Edit[i][j][9] << 3) | \ ((Tone_Op_Edit[i][j][0] & 0x70) >> 4) # print(f"{tone_data[i* TONE_PARAM_SIZE + j* OP_PARAM_SIZE +9]:4}") # footer tone_data[TONE_PARAM_SIZE * TONE_NUM +0] = 0x80 # print(f"footer 1 = {tone_data[TONE_PARAM_SIZE * TONE_NUM +0]}") tone_data[TONE_PARAM_SIZE * TONE_NUM +1] = 0x03 # print(f"footer 2 = {tone_data[TONE_PARAM_SIZE * TONE_NUM +1]}") tone_data[TONE_PARAM_SIZE * TONE_NUM +2] = 0x81 # print(f"footer 3 = {tone_data[TONE_PARAM_SIZE * TONE_NUM +2]}") tone_data[TONE_PARAM_SIZE * TONE_NUM +3] = 0x80 # print(f"footer 4 = {tone_data[TONE_PARAM_SIZE * TONE_NUM +3]}") #Burst write mode # print("YMF85 Burst write mode.") spi_write_single(0x08, 0xF6) # delay(20) delay(10) # Before 1000 spi_write_single(0x08, 0x00) #Write tone data to YMF825 FIFO print("Write tone data to YMF825.") spi_write_multi(0x07, tone_data) def copyTone2_Voice(num): tone_num = num & 0x0F global Tone_Com_Orig global Tone_Op_Orig global Tone_Com_Edit global Tone_Op_Edit global Voice_Com_Edit global Voice_Op_Edit # common parameter Voice_Com_Edit[BO][CM2] = (Tone_Com_Orig[tone_num] & 0x60) >> 5 Voice_Com_Edit[LFO][CM2] = (Tone_Com_Orig[tone_num] & 0x18) >> 3 Voice_Com_Edit[ALG][CM2] = Tone_Com_Orig[tone_num] & 0x07; Voice_Com_Edit[BO][CM1] = (Tone_Com_Edit[tone_num] & 0x60) >> 5 Voice_Com_Edit[LFO][CM1] = (Tone_Com_Edit[tone_num] & 0x18) >> 3 Voice_Com_Edit[ALG][CM1] = Tone_Com_Edit[tone_num] & 0x07 # operator s parameter for j in range(FM_OP_NUM): # j : 0 - 3 Voice_Op_Edit[SR][j +5] = (Tone_Op_Orig[tone_num][j][3] & 0x0F) Voice_Op_Edit[SR][j +1] = (Tone_Op_Edit[tone_num][j][3] & 0x0F) Voice_Op_Edit[XOF][j +5] = ((Tone_Op_Orig[tone_num][j][0] & 0x08) >> 3) Voice_Op_Edit[XOF][j +1] = ((Tone_Op_Edit[tone_num][j][0] & 0x08) >> 3) Voice_Op_Edit[KSR][j +5] = ((Tone_Op_Orig[tone_num][j][0] & 0x04) >> 2) Voice_Op_Edit[KSR][j +1] = ((Tone_Op_Edit[tone_num][j][0] & 0x04) >> 2) Voice_Op_Edit[RR][j +5] = (Tone_Op_Orig[tone_num][j][4] & 0x0F) Voice_Op_Edit[RR][j +1] = (Tone_Op_Edit[tone_num][j][4] & 0x0F) Voice_Op_Edit[DR][j +5] = (Tone_Op_Orig[tone_num][j][2] & 0x0f) Voice_Op_Edit[DR][j +1] = (Tone_Op_Edit[tone_num][j][2] & 0x0f) Voice_Op_Edit[AR][j +5] = (Tone_Op_Orig[tone_num][j][1] & 0x0F) Voice_Op_Edit[AR][j +1] = (Tone_Op_Edit[tone_num][j][1] & 0x0F) Voice_Op_Edit[SL][j +5] = (Tone_Op_Orig[tone_num][j][5] & 0x0F) Voice_Op_Edit[SL][j +1] = (Tone_Op_Edit[tone_num][j][5] & 0x0F) Voice_Op_Edit[TL][j +5] = (Tone_Op_Orig[tone_num][j][6] & 0x3F) Voice_Op_Edit[TL][j +1] = (Tone_Op_Edit[tone_num][j][6] & 0x3F) Voice_Op_Edit[KSL][j +5] = (Tone_Op_Orig[tone_num][j][0] & 0x03) Voice_Op_Edit[KSL][j +1] = (Tone_Op_Edit[tone_num][j][0] & 0x03) Voice_Op_Edit[DAM][j +5] = ((Tone_Op_Orig[tone_num][j][7] & 0x60) >> 5) Voice_Op_Edit[DAM][j +1] = ((Tone_Op_Edit[tone_num][j][7] & 0x60) >> 5) Voice_Op_Edit[EAM][j +5] = ((Tone_Op_Orig[tone_num][j][7] & 0x10) >> 4) Voice_Op_Edit[EAM][j +1] = ((Tone_Op_Edit[tone_num][j][7] & 0x10) >> 4) Voice_Op_Edit[DVB][j +5] = ((Tone_Op_Orig[tone_num][j][7] & 0x06) >> 1) Voice_Op_Edit[DVB][j +1] = ((Tone_Op_Edit[tone_num][j][7] & 0x06) >> 1) Voice_Op_Edit[EVB][j +5] = (Tone_Op_Orig[tone_num][j][7] & 0x01) Voice_Op_Edit[EVB][j +1] = (Tone_Op_Edit[tone_num][j][7] & 0x01) Voice_Op_Edit[MUL][j +5] = (Tone_Op_Orig[tone_num][j][8] & 0x0f) Voice_Op_Edit[MUL][j +1] = (Tone_Op_Edit[tone_num][j][8] & 0x0f) Voice_Op_Edit[DT][j +5] = ((Tone_Op_Orig[tone_num][j][8] & 0xf0) >> 4) Voice_Op_Edit[DT][j +1] = ((Tone_Op_Edit[tone_num][j][8] & 0xf0) >> 4) Voice_Op_Edit[WS][j +5] = (Tone_Op_Orig[tone_num][j][9] & 0x1F) Voice_Op_Edit[WS][j +1] = (Tone_Op_Edit[tone_num][j][9] & 0x1F) Voice_Op_Edit[FB][j +5] = ((Tone_Op_Orig[tone_num][j][0] & 0x70) >> 4) Voice_Op_Edit[FB][j +1] = ((Tone_Op_Edit[tone_num][j][0] & 0x70) >> 4) def copyVoice2_Tone(num): tone_num = num & 0x0F global Tone_Com_Edit global Tone_Op_Edit global Voice_Com_Edit global Voice_Op_Edit Tone_Com_Edit[tone_num] = ((Voice_Com_Edit[BO][CM1] << 5) | \ (Voice_Com_Edit[LFO][CM1] << 3) | \ Voice_Com_Edit[ALG][CM1]) # operator s parameter for j in range(FM_OP_NUM): # j : 0 - 3 Tone_Op_Edit[tone_num][j][0] = ((Voice_Op_Edit[FB][j +1] << 4) | \ (Voice_Op_Edit[XOF][j +1] << 3) | \ (Voice_Op_Edit[KSR][j +1] << 2) | \ (Voice_Op_Edit[KSL][j +1])) Tone_Op_Edit[tone_num][j][1] = Voice_Op_Edit[AR][j +1] Tone_Op_Edit[tone_num][j][2] = Voice_Op_Edit[DR][j +1] Tone_Op_Edit[tone_num][j][3] = Voice_Op_Edit[SR][j +1] Tone_Op_Edit[tone_num][j][4] = Voice_Op_Edit[RR][j +1] Tone_Op_Edit[tone_num][j][5] = Voice_Op_Edit[SL][j +1] Tone_Op_Edit[tone_num][j][6] = Voice_Op_Edit[TL][j +1] Tone_Op_Edit[tone_num][j][7] = ((Voice_Op_Edit[DAM][j +1] << 5) | \ (Voice_Op_Edit[EAM][j +1] << 4) | \ (Voice_Op_Edit[DVB][j +1] << 1) | \ (Voice_Op_Edit[EVB][j +1])) Tone_Op_Edit[tone_num][j][8] = ((Voice_Op_Edit[DT][j +1] << 4) | \ (Voice_Op_Edit[MUL][j +1])) Tone_Op_Edit[tone_num][j][9] = Voice_Op_Edit[WS][j +1] def serialOutVoiceData(num): tone_num = num & 0x0F global Voice_Com_Edit global Voice_Op_Edit print() print(f'Voice Number = {tone_num} : {ToneName[tone_num]}') # Voice Edit Common Parameter print(f'{Voice_Com_Edit[COM][CM0]:10}:', end = '') # Header for j in range(1, VOICE_COM_COL_NUM): print(f'{Voice_Com_Edit[COM][j]:> 5}|', end = '') print() # Body for i in range(1, VOICE_COM_ROW_NUM): # print(f'|{moji.strFixL_n(Voice_Com_Edit[i][CM0], 5)} ', ' :', end = '') print(f'{Voice_Com_Edit[i][CM0]:10}:', end = '') print(f'{Voice_Com_Edit[i][CM1]: 5}|', end = '') print(f'{Voice_Com_Edit[i][CM2]: 5}|', end = '') print(f'{Voice_Com_Edit[i][CM3]: 5}|') print() # Vice Edit Oparetor Parameter print(f'{Voice_Op_Edit[OPT][OP0]:10}:', end = '') # Header for j in range(1, VOICE_OP_COL_NUM): print(f'{Voice_Op_Edit[OPT][j]:> 3}|', end = '') print() # Body for i in range(1, VOICE_OP_ROW_NUM): # print(f'|{moji.strFixL_n(Voice_Com_Edit[i][CM0], 5)} ', ' :', end = '') print(f'{Voice_Op_Edit[i][OP0]:10}:', end = '') print(f'{Voice_Op_Edit[i][OP1]: 3}|', end = '') print(f'{Voice_Op_Edit[i][OP2]: 3}|', end = '') print(f'{Voice_Op_Edit[i][OP3]: 3}|', end = '') print(f'{Voice_Op_Edit[i][OP4]: 3}|', end = '') print(f'{Voice_Op_Edit[i][OP5]: 3}|', end = '') print(f'{Voice_Op_Edit[i][OP6]: 3}|', end = '') print(f'{Voice_Op_Edit[i][OP7]: 3}|', end = '') print(f'{Voice_Op_Edit[i][OP8]: 3}|', end = '') print(f'{Voice_Op_Edit[i][OP9]: 3}|') print() def serialOutToneData(num): tone_num = num & 0x0F global tone_data global Tone_Com_Edit global Tone_Op_Edit global ToneName # tone parameter data size COMMON_PARAM_SIZE = 2 OP_PARAM_SIZE = 7 TONE_PARAM_SIZE = COMMON_PARAM_SIZE + FM_OP_NUM * OP_PARAM_SIZE; MESSAGE_SIZE = TONE_PARAM_SIZE * TONE_NUM + 1 + 4 # 485 print() print("YMF825 Tone Parameter Setting Data") print(f'Voice Number = {tone_num} : {ToneName[tone_num]}') tone_data[tone_num * TONE_PARAM_SIZE +1] = (Tone_Com_Edit[i] & 0x60) >> 5 print(f"common parameter 1 = {tone_data[tone_num * TONE_PARAM_SIZE +1]:4}") # common parameter 2 tone_data[tone_num * TONE_PARAM_SIZE +2] = ((Tone_Com_Edit[i] & 0x18) << 3) | (Tone_Com_Edit[i] & 0x07) print(f"common parameter 2 = {tone_data[tone_num * TONE_PARAM_SIZE +2]:4}") # operator parameter 7 x 4 for j in range(FM_OP_NUM): print(f"operator parameter [{j}] = ", end = "") tone_data[tone_num * TONE_PARAM_SIZE + j* OP_PARAM_SIZE +3] = \ (Tone_Op_Edit[i][j][3] << 4) | \ (Tone_Op_Edit[i][j][0] & 0x08) | \ ((Tone_Op_Edit[i][j][0] & 0x04) >> 2) print(f"{tone_data[i* TONE_PARAM_SIZE + j* OP_PARAM_SIZE +3]:4},", end = "") tone_data[tone_num * TONE_PARAM_SIZE + j* OP_PARAM_SIZE +4] = \ (Tone_Op_Edit[i][j][4] << 4) | Tone_Op_Edit[i][j][2] print(f"{tone_data[i* TONE_PARAM_SIZE + j* OP_PARAM_SIZE +4]:4},", end = "") tone_data[tone_num * TONE_PARAM_SIZE + j* OP_PARAM_SIZE +5] = \ (Tone_Op_Edit[i][j][1] << 4) | Tone_Op_Edit[i][j][5] print(f"{tone_data[i* TONE_PARAM_SIZE + j* OP_PARAM_SIZE +5]:4},", end = "") tone_data[i* TONE_PARAM_SIZE + j* OP_PARAM_SIZE +6] = \ (Tone_Op_Edit[i][j][6] << 2) | (Tone_Op_Edit[i][j][0] & 0x03) print(f"{tone_data[i* TONE_PARAM_SIZE + j* OP_PARAM_SIZE +6]:4},", end = "") tone_data[i* TONE_PARAM_SIZE + j* OP_PARAM_SIZE +7] = \ Tone_Op_Edit[i][j][7] print(f"{tone_data[i* TONE_PARAM_SIZE + j* OP_PARAM_SIZE +7]:4},", end = "") tone_data[i* TONE_PARAM_SIZE + j* OP_PARAM_SIZE +8] = \ ((Tone_Op_Edit[i][j][8] & 0x0f) << 4) | \ ((Tone_Op_Edit[i][j][8] & 0xf0) >> 4) print(f"{tone_data[i* TONE_PARAM_SIZE + j* OP_PARAM_SIZE +8]:4},", end = "") tone_data[i* TONE_PARAM_SIZE + j* OP_PARAM_SIZE +9] = \ (Tone_Op_Edit[i][j][9] << 3) | \ ((Tone_Op_Edit[i][j][0] & 0x70) >> 4) print(f"{tone_data[i* TONE_PARAM_SIZE + j* OP_PARAM_SIZE +9]:4}") # footer tone_data[TONE_PARAM_SIZE * TONE_NUM +0] = 0x80 print(f"footer 1 = {tone_data[TONE_PARAM_SIZE * TONE_NUM +0]}") tone_data[TONE_PARAM_SIZE * TONE_NUM +1] = 0x03 print(f"footer 2 = {tone_data[TONE_PARAM_SIZE * TONE_NUM +1]}") tone_data[TONE_PARAM_SIZE * TONE_NUM +2] = 0x81 print(f"footer 3 = {tone_data[TONE_PARAM_SIZE * TONE_NUM +2]}") tone_data[TONE_PARAM_SIZE * TONE_NUM +3] = 0x80 print(f"footer 4 = {tone_data[TONE_PARAM_SIZE * TONE_NUM +3]}") #Reset and Initialize YMF825 # PicoMain では、使用しない。 def init_YMF825(): YMF825_reset.low() # print("RESET LOW") # C-out delay(100) # Before 1000 YMF825_reset.high() delay(100) # Before 1000 # print("Reset YMF825.") # C-out spi_write_single(0x1D,0x00) spi_write_single(0x02,0x0E) delay(20) spi_write_single(0x00,0x01) spi_write_single(0x01,0x00) spi_write_single(0x1A,0xA3) delay(20) spi_write_single(0x1A,0x00) delay(40) spi_write_single(0x02,0x04) delay(20) spi_write_single(0x02,0x00) # add spi_write_single(0x19,0xFF) spi_write_single(0x1B,0x3F) spi_write_single(0x14,0x00) spi_write_single(0x03,0x01) spi_write_single(0x08,0xF6) delay(40) spi_write_single(0x08,0x00) spi_write_single(0x09,0xF8) spi_write_single(0x0A,0x00) spi_write_single(0x17,0x40) spi_write_single(0x18,0x00) print("YMF825 initialized.") # YMF825 Set up hardware # PicoMain では、使用しない。 def setup(): led_turn(True) chip_select(False) print("Set up YMF825") init_YMF825() set_chanel() print("Finished setting up.") led_turn(False) ``` ### mojipy.py ```MicroPython:mojipy.py ############################################################################# # mojipy.py # 2024/04/15：文字処理をライブラリ化：Programd by Hyodo # Thonny で Pico直下にコピーしておき # import mojipy as moji として利用する #---------------------------------------------------------------------------- # 整数を 16進数表記のASCII文字（0～9 A～F）２文字に変換する。 # 整数を 10進数表記のASCII文字に変換するには str(num) でよい。 def int2asc2(num): num_H = int(num / 16) num_L = num % 16 if num_H > 9: num_H = num_H - 9 asc_H = chr(0x40 + num_H) else: asc_H = chr(0x30 + num_H) if num_L > 9: num_L = num_L - 9 asc_L = chr(0x40 + num_L) else: asc_L = chr(0x30 + num_L) return asc_H, asc_L #---------------------------------------------------------------------------- # ２バイト以上の16進数表記のASCIIコード（0～9、A～F a～f）を整数に変換する。 # 10進数表記のASCIIコードを整数に変換するには int(s) でよい。 # int2asc2(num)関数の逆操作 def asc2int(s): l = len(s) data_int = 0 # rcv_data は、s の i 番目の要素を示す 「Python入門」p140 参照 for i, rcv_data in enumerate(s): # print("rcv_data[{}] = {} ".format(i, ord(rcv_data))) data_ascii = ord(rcv_data) # print("rcv_ascii[{}] = {} ".format(i, data_ascii), end="") if data_ascii >= 48 and data_ascii <= 57: data_int += (data_ascii - 48) * 16 ** (l - i - 1) elif data_ascii >= 65 and data_ascii <= 70: data_int += ((data_ascii - 65) + 10) * 16 ** (l - i - 1) elif data_ascii >= 97 and data_ascii <= 102: data_int += ((data_ascii - 97) + 10) * 16 ** (l - i - 1) return data_int #---------------------------------------------------------------------------- # １バイトデータを４ビットｘ２に分け、0～9 A～F ２文字（２バイト）に変換する。 # chr2dec(s)関数（１６進表記の文字列を 0x00 〜 0xFF の数値に変換）の逆操作 def byte2chr2(num): num_H = int(ord(num) / 16) num_L = ord(num) % 16 if num_H > 9: num_H = num_H - 9 str_H = chr(0x40 + num_H) else: str_H = chr(0x30 + num_H) if num_L > 9: num_L = num_L - 9 str_L = chr(0x40 + num_L) else: str_L = chr(0x30 + num_L) return str_H + str_L #---------------------------------------------------------------------------- # ２バイト以上のAsciiコード（0～9、A～F a～f）を数値に変換する。 # byte2chr2(num)関数（１バイトを１６進表記２文字に変換）の逆操作 # 2023/11/27：この関数は、次の式と同じであるが、Value Errorを生じさせない。 # return int("0x" + s) def chr2dec(s): l = len(s) data_hex = 0 # rcv_data は、s の i 番目の要素を示す 「Python入門」p140 参照 for i, rcv_data in enumerate(s): # print("rcv_data[{}] = {} ".format(i, ord(rcv_data))) data_ascii = ord(rcv_data) # print("rcv_ascii[{}] = {} ".format(i, data_ascii), end="") if data_ascii >= 48 and data_ascii <= 57: data_hex += (data_ascii - 48) * 16 ** (l - i - 1) elif data_ascii >= 65 and data_ascii <= 70: data_hex += ((data_ascii - 65) + 10) * 16 ** (l - i - 1) elif data_ascii >= 97 and data_ascii <= 102: data_hex += ((data_ascii - 97) + 10) * 16 ** (l - i - 1) return data_hex #---------------------------------------------------------------------------- # 数値を指定桁の数字文字列に変換・・・数字を右詰め、先頭の余白は、スペース # 20240328 Name Change def int2str_n(num, n): # int num, n:桁数 sp_n = ' ' * n # 最大桁数分 スペース # sp_n = '0' * n とする方法あり str_num = sp_n + str(num) # 先頭側に スペース return str_num[-n:] # 末尾の n桁 #---------------------------------------------------------------------------- # 文字列項目を固定桁数に編集・・・文字を左詰め、末尾の余白は、スペース # 20240328 Name Change def strFixL_n(str_x, n): # n:桁数 sp_n = ' ' * n # 最大桁数分 スペース str_x += sp_n # 末尾側に スペース return str_x[:n] # 先頭の n桁 #---------------------------------------------------------------------------- # 文字列項目を固定桁数に編集・・・文字を左詰め、末尾の余白は、0 # 20240328 Name Change def strFixLZ_n(str_x, n): # n:桁数 sp_n = '0' * n # 最大桁数分 0 str_x += sp_n # 末尾側に 0 return str_num[:n] # 先頭の n桁 #---------------------------------------------------------------------------- # 文字列項目を固定桁数に編集・・・文字を右詰め、先頭の余白は、スペース # 20240328 Name Change def strFixR_n(str_x, n): # n:桁数 sp_n = ' ' * n # 最大桁数分 スペース sp_n += str_x # 先頭側に スペース return sp_n[-n:] # 末尾の n桁 #---------------------------------------------------------------------------- ``` プログラム全体の見通しを良くするため「main.py」はできるだけ小さくして、タッチパネルを利用した音源パラメータ編集プログラムは、「tone_edit.py」に関数を集めモジュール化しました。 LCD表示やタッチパネル座標取得は「touch_lcd.py」、タブ表示やタブ座標などを管理する「tab_cdn.py」、SD-Cardへの読み書きを担当する「sdcard.py」などもモジュールとして「lib」フォルダ下にします。「tone_edit.py」は200KBを超える大きさになってしまいました。 ## PicoSub側のプログラム PicoSubプログラムは、次のプログラムで構成されています。 PicoSubプログラム側の説明は本題と外れますので省きます。 一部、関係のないプログラムが入っています。 ### main.py ```MicroPython:main.py ############################################################################# # YMF825で演奏するための PicoSub側のプログラム # PicoS_YMF825Midi-061.py Programed by Hyodo # # PicoMain と PicoSub で分担して処理する。このプログラムは、PicoSub用のプログラムである。 # PicoMain と PicoSub 間は、シリアル通信で接続する。 # PicoMain で YMF825の音源パラメータ（ToneData）などを編集し、PicoSubに送信する。 # PicoSub は、MIDI信号を受信し、YMF825で音出し（演奏）するとともに、MIDI-OUTにも出力する。 # # 実現できたこと # MIDI信号を受信し、YMF825で音出し（演奏）するとともに、MIDI-OUTにも信号を出す。 # YMF825 の音源は 16しかないが、GM音源に対応できるように、ToneTableを用意して適当に割った。 # MIDI-OUT側に、ポケットミクなどの音源を接続すれば、YMF825 と並行して音出しができる。 # # MIDI Keyboard（鍵盤）の入力で、YMF825 で和音を出すため、空きチャンネルを割り振る方法を採用した。 # # # YMF825による音出しはは、Shunsuke Ohira さんのプログラムを参考にした。 # # YMF825 との接続 # PICO gpio name (pin) (pin) YMF825 # gpio-17 SPI CS (22) ----白---- (1) SS # gpio-19 SPI MOSI (25) ----青---- (2) MOSI # gpio-16 SPI MISO (21) ----緑---- (3) MISO # gpio-18 SPI CLK (24) ----黄---- (4) CLK # GND -----------白---- (5) GND # 5V -----------橙---- (6) VCC # gpio-22 RESET (29) ----紫---- (7) RST # No Connect (8) Audio Jack # # YMF825 Monitor LED-BLUE # gpio-28 (34) --- BLUE-LED Anode --->--- Cathode (GND) # # # PicoMain と PicoSub との接続 # <<< PicoMain >>> Low True <<< PicoSub >>> # gpio-2 respT (4) --紫-- --黄-- (4) respT gpio-2 # X # gpio-3 respR (5) --黄-- --紫-- (5) respR gpio-3 # # gpio-4 TX (6) --緑-- --青-- (6) TX gpio-4 # X # gpio-5 RX (7) --青-- --緑-- (7) RX gpio-5 # # # Aques Talk との接続・・・このプログラムでは未使用 # <<< PicoSub >>> <<< Aques Talk ATP3012 >>> # (Pin) (Pin:ATP3012) # gpio-12 spi1_MISO (16) --緑-- (18) MISO # gpio-13 spi1_CE (17) --黃-- (16) /SS # gpio-14 spi1_CKL (19) --紫-- (19) SCK # gpio-15 spi1_MOSI (20) --青-- (17) MOSI # +5V --赤-- VCC # GND --白-- GND # # # PicoS(YMF825)HectOne-026.py をベースに、イコライザー（フィルター）機能を追加した # ものを残している ############################################################################# from machine import Timer, SPI, UART, Pin import time import utime import uos from micropython import const # 20240919 Add import math import ymf825py as ymf825 import mojipy as moji ############################################################################# # 上記インポートファイルは、予め、Picoに書き込んでおくこと # ymf825py.py : YMF825 接続用 # mojipy.py : 文字処理用 ############################################################################# HectOneVoice = [ # 01 tenchitennno- ['akinotano,','karihonoiono,', 'tomaoarami-,', 'wagakoromodewa,', 'tuyuninuretutu-.'], # 02 jito-tennno- ['harusugite,', 'natukinikerasi,', 'sirotaeno-,', 'koromohosutyo-,', 'amanokaguyama-.'], # 03 kakinomotonmo hitomaro ['asibikino,', 'yamadorinoono,', 'sidariono-,', 'naganagasiyowo,', 'hitorikamunenn-.'], # 04 yamabeno akahito ['tagonoura,', 'utidetemireba,', 'sirotaeno-,', 'fujinotakaneni,', 'yukiwafuritutu-.'], # 05 sarumaru dayu- ['okuyamani,', 'momijikakiwake,', 'nakusikano-,', 'koekikutokizo,', 'akiwakanasiki-.'], # 06 tyuunagionn nakamoti ['kasasagino,', 'wataseruhasini,', 'okusimono-,', 'sirokiomireba,', 'yozofukenikeru-.'], # 07 ['amanohara,', 'furisakemireba,', 'kasuganaru-,', 'mikasanoyamani,', 'idesitukikamo-.'], # 08 ['toppann,', 'ippann,', 'nippann,', 'nissann,', 'hyakuninnissyu.'], # 09 ['', '', '', '', ''], # 10 ['', '', '', '', ''], # 11 ['', '', '', '', ''], # 12 ['', '', '', '', ''], # 13 ['', '', '', '', ''], # 14 ['', '', '', '', ''], # 15 ['', '', '', '', ''], ] # MIDI Keyboard 入力を ch に振り分けるためのリスト TONE_NUM = const(16) ChList = [None] *TONE_NUM # KeyOn 起動で、NoteOff までのタイマー値 note_off_timer = [-1] *TONE_NUM NOTE_OFF_TIME = 4000 # シリアル uart_midi を生成 # MIDI は、31250bpsである。 MIDI_BAUD_RATE = 31250 # uart_midi = UART(1, MIDI_BAUD_RATE,bits=8,parity=None,stop=1,tx=Pin(8),rx=Pin(9)) uart_midi = UART(0, MIDI_BAUD_RATE,bits=8,parity=None,stop=1,tx=Pin(0),rx=Pin(1)) uartRespT = Pin(2, Pin.OUT) # Low TRUE uartRespT.value(1) uartRespR = Pin(3, Pin.IN) # Low TRUE # spi1 Aques Talk MODE=3 spi1 = SPI(1, baudrate=1000000, polarity=1, phase=1, sck=Pin(14), mosi=Pin(15), miso=Pin(12)) aques_cs = Pin(13, Pin.OUT) aques_cs.value(1) # 初期状態:1 # 時分割処理のためのタイマー # global変数定義。関数で利用するグローバル変数は、関数の定義前に書くのが無難。 uart_timer = 0 # UART RTS CTS Timer uartRtsReq = 0 # UART RTS Request 1:Request uartRtsBusy = 0 # UART RTS Busy 1:Busy MONOTONE_TIME = const(8000) # MIDI受信タイマー monoTone_timer = 0 spi_timer = 0 # SPI Time # 10ms 毎に割り込みが発生する なぜか引数 (t) は必須である。 def every10ms(t): global uart_timer, uartRespR, uartRtsReq, uartRtsBusy global monoTone_timer, note_off_timer global spi_timer if uart_timer < 10: uart_timer = 0 else: uart_timer -= 10 if uartRespR.value() == 0 and uartRtsBusy == 0: # PicoMain から送信要求あり uartRtsReq = 1 if monoTone_timer < 10: monoTone_timer = 0 else: monoTone_timer -= 10 if spi_timer < 10: spi_timer = 0 else: spi_timer -= 10 # note_off_timer for ch in range(TONE_NUM): if note_off_timer[ch] < 10 and note_off_timer[ch] >= 0: ymf825.note_off(ch) # 空きチャンネルにする ChList[ch] = 0 note_off_timer[ch] = -1 elif note_off_timer[ch] >= 10: note_off_timer[ch] -= 10 else: # note_off_timer[ch] < 0 pass # 20240416 10ms # 10ms 毎に every1ms を呼び出す呪文。これ以前に callback関数を定義のこと。 # Timer(period=10, mode=Timer.PERIODIC, callback=every1ms) # mode=Timer.PERIODIC は、指定しなくても大丈夫のようだ。 ############################################################################## # Main 直前で起動するするのが無難か # Timer(period=10, callback=every10ms) ############################################################################## # MicroPython説明サイトでは、タイマーの初期化を行っているが、なくても動作する。 # tim = Timer(period=1, mode=Timer.PERIODIC, callback=every1ms) # tim.init(period=1, callback=every1ms) ####################################################################### # HandShake Send RTS & Recive CTS Cross Connection # PicoMain と PicoSub との接続 # <<< PicoMain >>> Low True <<< PicoSub >>> # gpio-2 respT (4) --紫-- --黄-- (4) respT gpio-2 # X # gpio-3 respR (5) --黄-- --紫-- (5) respR gpio-3 # def waitCTS(rts, time, msg, cnt): global uart_timer if rts == 0: # Send RTS On uartRespT.value(0) uart_timer = time # Wait CTS On while uartRespR.value() == 1: # On == Low になるのを待つ if uart_timer == 0: print(msg) uart_timer = time if cnt > 0: cnt -= 1 else: break # Pico Sub と UART 通信できない utime.sleep_ms(10) elif rts == 1: # Send RTS Off uartRespT.value(1) uart_timer = time # Wait CTS Off while uartRespR.value() == 0: # Off == High になるのを待つ if uart_timer == 0: print(msg) uart_timer = time if cnt > 0: cnt -= 1 else: break # Pico Sub と UART 通信できない utime.sleep_ms(10) elif rts == 2: # Sub-Pico で利用 # Send RTS On uartRespT.value(0) uart_timer = time # Wait CTS Off while uartRespR.value() == 0: # Off == High になるのを待つ if uart_timer == 0: print(msg) uart_timer = time if cnt > 0: cnt -= 1 else: break # Pico Sub と UART 通信できない utime.sleep_ms(10) return cnt ####################################################################### # PicoMain からの受信処理 def uartComRcv(): global uartRespR, uartRespT, uartRtsReq, uartRtsBusy, tone_num, play_mode # 念のために確認 if uartRespR.value() == 0: # 念のためにから読みする ymf825.uart_blank_read() print('RTS arrived from Main-Pico') # Main Pico へ送信可を送出して、送信完了を待つ print('RTS On(0) to Main_Pico') cnt = 3 # RTS On(0) Wait CTS Off(1) = 送信完了 cnt = waitCTS(2, 1000, 'Wait UART data ...', cnt) # uartRespR.value() == 1 を待って if cnt > 0: uartRespT.value(1) # Toneリストを UART から読み込む # utime.sleep_ms(10) try: (rcv_size, headerID, tone_name) = ymf825.uartInTone() except: print('Error : on (rcv_size, headerID, tone_name) = ymf825.uartInTone() : NoneType?') rcv_size = 0 try: if rcv_size > 0: print() print(f'rcv_size={rcv_size} headerID={headerID} tone_name={tone_name}') # headerID == '0' : ToneData ならば if headerID == '0': # 読み込んだ Toneリストを、Tone_Com_Edit と Tone_Op_Edit に格納する # UART から受け取った Toneリストの tone_num を取得 tone_num = ymf825.takeInToneData() # ToneName 更新 ymf825.ToneName[tone_num] = tone_name # ToneMenuTable 更新 ・・・ PicoSubでは利用しないが ymf825.ToneMenuTable[tone_num +1][1] = tone_name # 内容をシリアル出力する # ymf825.serialOutToneData(tone_num) ymf825.copyTone2_Voice(tone_num) ymf825.serialOutVoiceData(tone_num) ymf825.init_tone() print('受信した音源で発音テスト（ToneTable の登録に従って音出し）') print('DoMiSo', tone_num, ymf825.ToneName[tone_num], 'Octave:4') ymf825.keyon5(0, 4, ymf825.KEY_C, 40, tone_num) utime.sleep_ms(1000) ymf825.keyon5(1, 4, ymf825.KEY_E, 40, tone_num) utime.sleep_ms(1000) ymf825.keyon5(2, 4, ymf825.KEY_G, 40, tone_num) utime.sleep_ms(1000) ymf825.keyoff(0) ymf825.keyoff(1) ymf825.keyoff(2) # headerID == '1' : ToneTable ならば elif headerID == '1': # ToneTable に格納 print('ymf825.takeInToneTable()') ymf825.takeInToneTable() # headerID == '%' : PrintDFP Command ならば elif headerID == '%': # PrintDFP Command を uart に送信 print('ymf825.uart_write_multi(PrintDFP Command)') ymf825.uart_write_multi(tone_name) # headerID == '2' : YMF825 Play Mode ならば elif headerID == '2': # play_mode Command を 受信 print('Recived play_mode Command') play_mode = tone_name.strip() # 文字列にする play_mode = play_mode.decode('utf-8') print(f'play_mode = {play_mode}') except TypeError: print('uartComRcv(): rcv_size > 0:') else: print() print('CTS Off(1) signal not comming from Main-Pico') print('ymf825.uartInTone() was not performed !!!') print('Check the connection with Main-Pico') print() # Send RTS Off uartRespT.value(1) utime.sleep_ms(1000) else: # print('RTS is not arrived') uartRespT.value(1) utime.sleep_ms(10) ####################################################################### # note_off_timer[0-15] を -1:TimeOver にする def init_note_off_timer(): global note_off_timer for ch in range(TONE_NUM): # ch 0-15 note_off_timer[ch] = -1 # -1:TimeOver ####################################################################### def check_and_set_ChList(kk): global ChList try: # すでに利用中の kk であるか？ ch = ChList.index(kk) # エラーでなければ（見つかったなら）、その ch をそのまま利用する。 ############################# # 一旦、ノートオフにする print(f' note off ch = {ch}') ymf825.note_off(ch) utime.sleep_ms(50) ############################# return ch except ValueError: # エラーならば（利用中ではないなら）、空き ch を探す。 try: ch = ChList.index(0) # チャンネルを kk で使用中にする ChList[ch] = kk return ch except ValueError: return 16 ####################################################################### # ChList は整数リストとする # ChList（整数リスト）を 0クリアする def initChList(): global ChList # 0:空きチャンネル for ch in range(TONE_NUM): # ch 0-15 ChList[ch] = 0 ####################################################################### # ChList は整数リストとする # ChList（整数リスト）から、最初に見つかった 0 の位置（空きインデックス）を返す # 見つからなければ 16を返す def setChList(kk): global ChList try: ch = ChList.index(0) # チャンネルを kk で使用中にする ChList[ch] = kk return ch except ValueError: return 16 ####################################################################### # ChList は整数リストとする # ChList（整数リスト）から、最初に見つかった kk の位置（インデックス）を返す # 見つからなければ 16を返す def resetChList(kk): global ChList try: ch = ChList.index(kk) # 空きチャンネルに戻す ChList[ch] = 0 return ch except ValueError: return 16 ####################################################################### def allNoteOff(): for ch in range(16): # ch 0-15 ymf825.note_off(ch) utime.sleep_ms(10) ####################################################################### def sendAllNoteOffMidi(): midi_msg = bytearray(3) # オール・サウンド・オフ for ch in range(16): # ch 0-15 midi_msg[0] = 0xB0 + ch midi_msg[1] = 0x78 midi_msg[2] = 0x00 uart_midi.write(midi_msg) utime.sleep_ms(10) # オール・ノート・オフ for ch in range(16): # ch 0-15 midi_msg[0] = 0xB0 + ch midi_msg[1] = 0x7B midi_msg[2] = 0x00 uart_midi.write(midi_msg) utime.sleep_ms(10) ####################################################################### # note off = 8n kk vv or 9n kk 00 # note on = 9n kk vv # midi_rcvbuff から note on, note off 情報を抽出して ymf825に送る。 def noteYmf825(midi_rcvbuff): print('noteYmf825', end='') ch = moji.asc2int(midi_rcvbuff[0:2]) % 16 kk = moji.asc2int(midi_rcvbuff[2:4]) & 0x7F vv = moji.asc2int(midi_rcvbuff[4:6]) & 0x7F # note off if midi_rcvbuff[0] == '8' or (midi_rcvbuff[0] == '9' and vv == 0): print(' note off', ch) ymf825.note_off(ch) # note on # 20240928 Edit elif midi_rcvbuff[0] == '9' and vv != 0: octave = int(kk / 12) -1 key = kk % 12 print(' note on', ch, octave, key, vv) ymf825.note_on(ch, octave, key, vv) ####################################################################### # note on = 9n kk vv のみに対応し、 # note off = 8n kk vv or 9n kk 00 には直接反応せず、一定時間後に対応するモード。 # midi_rcvbuff から note on, note off 情報を抽出して ymf825に送る。 # midi Keyboard 入力で和音を出すために MONO TONE でチャンネルを振り分ける # 20240927 def noteMonoToneYmf825(midi_rcvbuff): を改造した。 def noteChaimeModeYmf825(midi_rcvbuff): # PicoMain から受信した tone_num で演奏する global tone_num print('noteKeyboardYmf825', end='') # ch = moji.asc2int(midi_rcvbuff[0:2]) % 16 kk = moji.asc2int(midi_rcvbuff[2:4]) & 0x7F vv = moji.asc2int(midi_rcvbuff[4:6]) & 0x7F if midi_rcvbuff[0] == '8' or (midi_rcvbuff[0] == '9' and vv == 0): # note off # なにもしない pass elif midi_rcvbuff[0] == '9' and vv != 00: # note on # 同一 kk で利用チャンネルを探す、なければ、空きチャンネルを探す ch = check_and_set_ChList(kk) print(f' {ch} = check_and_set_ChList({kk})', end = '') if ch >= 0 and ch < TONE_NUM: # ch 0-15 octave = int(kk / 12) -1 key = kk % 12 print(f' note on ch={ch} octave={octave} key={key} velocity={vv} tone={tone_num}') ymf825.note_onMonoTone(ch, octave, key, vv, tone_num) # タイマーをセット note_off_timer[ch] = NOTE_OFF_TIME else: # ch 0-15 以外なら # 何もしない pass ####################################################################### # MIDIの Program Change情報に基づき、ToneTable を編集する。 # MIDI受信したGM音源（1-128）を ymf825 の音色に変換して、ToneTableに記録する。 def changeToneTable(midi_rcvbuff): print('PROGRAM CHANGE ', end='') ch = moji.asc2int(midi_rcvbuff[0:2]) % 16 gm = moji.asc2int(midi_rcvbuff[2:4]) & 0x7F ymf = ymf825.exGmYmf825.get(gm) # ToneTable の更新 ymf825.ToneTable[ch +1][1] = ymf # ドラム(9)は、無音にする ymf825.ToneTable[9 +1][1] = 16 print('ch = ', ch, 'GM = ', gm, 'YMF825 = ', ymf) ####################################################################### # MIDI 入力を演奏する # Keyboardからの MIDIは、ch=0 だけなので、 MONO TONE にして和音対応する。 # Chaime Mode = Key On で発音し、 Key off 後も一定時間（４秒）持続する。 # 20240717：def noteMonoToneYmf825(midi_rcvbuff): 関数を内蔵して自動切り替えする。 # PicoMain からの送信要求（uartRtsReq）があれば、中断する。 # 20240927：def midiPlayYmf825(): を改造して作成。 def midiPlayChaimeModeYmf825(): global uartRespR, uartRtsReq, uartRtsBusy global monoTone_timer midi_rcvbuff = "" note_Flag = 0 note_Byte = 0 prg_Flag = 0 prg_Byte = 0 status_Flag = 0 # 0:mono_toneでない通常のmidi：MIDI受信した Program Change（音色変更）を利用する # 1:Keyboard:ch分割で和音対応：PicoMainから受信したToneDataを利用する # MIDI信号があれば、1 から 0 に切り替える。 mono_tone = 1 # チャンネルリストを 0 クリア initChList() # ノートオフタイマーを初期設定 init_note_off_timer() # PicoMain から送信要求があれば中断する while uartRtsReq == 0: # MIDI 受信ありなら if uart_midi.any() > 0: try: # uart_midi から、１データ読み込む（decodeなし=bytesデータのまま） midi_data_rx = uart_midi.read(1) except UnicodeError: # 読み込みエラーになるの？なら print("uart_midi.read(1) Error!!") midi_data_rx = "" # 受信した１バイトを２バイトの文字に変換して、シリアル出力する # print(moji.byte2chr2(midi_data_rx), end="") # 受信データを２バイトの文字データにして追加保存する midi_rcvbuff += moji.byte2chr2(midi_data_rx) # MIDI受信が８秒以上なければ、mono_tone = 1 にする ############################################## monoTone_timer = MONOTONE_TIME ############################################## ######################################################################### # note on または note off ならば if ord(midi_data_rx) >= 0x80 and ord(midi_data_rx) <= 0x9F: note_Flag = 1 note_Byte = 1 prg_Flag = 0 status_Flag = 0 # note on または note off のデータならば elif ord(midi_data_rx) < 0x80 and note_Flag == 1: note_Byte += 1 if note_Byte == 3: # データをシリアル出力する print(" >>> midi_rcvbuff = ", midi_rcvbuff) ##################################################### if mono_tone == 1: # mono_tone ###################################### # noteMonoToneYmf825(midi_rcvbuff) noteChaimeModeYmf825(midi_rcvbuff) ###################################### else: # MIDI受信した Program Change（音色変更）を利用した演奏 noteYmf825(midi_rcvbuff) ##################################################### note_Byte = 0 #################### midi_rcvbuff = "" note_Flag = 0 prg_Flag = 0 status_Flag = 0 #################### # Program Change（音色変更）ならば elif ord(midi_data_rx) >= 0xC0 and ord(midi_data_rx) <= 0xCF: mono_tone = 0 prg_Flag = 1 prg_Byte = 1 note_Flag = 0 status_Flag = 0 # Program Change（音色変更）のデータならば elif ord(midi_data_rx) < 0x80 and prg_Flag == 1: prg_Byte += 1 if prg_Byte == 2: # ToneTable を更新する print(" >>> midi_rcvbuff = ", midi_rcvbuff) # ############################## changeToneTable(midi_rcvbuff) ############################## prg_Byte = 0 #################### midi_rcvbuff = "" note_Flag = 0 prg_Flag = 0 status_Flag = 0 #################### # その他の情報ならば、何もしない else: #################### midi_rcvbuff = "" note_Flag = 0 prg_Flag = 0 status_Flag = 0 #################### elif monoTone_timer == 0: # MIDI受信が８秒以上なければ、mono_tone = 1 にする ############################################## mono_tone = 1 ############################################## # while uartRtsReq != 0 PicoMain から送信要求があれば中断する else: print('Recived uartRtsReq !') # YMF825 allNoteOff() # MIDI sendAllNoteOffMidi() uartRtsBusy = 1 return ####################################################################### # MIDI 入力を YMF825で演奏する # 20251117：Ch0 以外なら MIDI 出力する機能を追加・・・ポケットミクをつなげる。 # 20251118：sw_ch （Swap Channel）が、0 以外なら、Ch0 をその sw_ch に出力する。 # Keyboardからの MIDIは、ch=0 だけなので、 MONO TONE にして和音対応する。 # 20240717：def noteMonoToneYmf825(midi_rcvbuff): 関数を内蔵して自動切り替えする。 # PicoMain からの送信要求（uartRtsReq）があれば、中断する。 def midiPlayYmf825(): global uartRespR, uartRtsReq, uartRtsBusy global monoTone_timer global sw_ch midi_rcvbuff = "" note_Flag = 0 note_Byte = 0 prg_Flag = 0 prg_Byte = 0 status_Flag = 0 # 0:mono_toneでない通常のmidi：MIDI受信した Program Change（音色変更）を利用する # 1:Keyboard:ch分割で和音対応：PicoMainから受信したToneDataを利用する # MIDI信号があれば、1 から 0 に切り替える。 mono_tone = 1 # チャンネルリストを 0 クリア initChList() # midiモニターバッファ midiMB = '' # PicoMain から送信要求があれば中断する while uartRtsReq == 0: # MIDI 受信ありなら if uart_midi.any() > 0: try: # uart_midi から、１データ読み込む（decodeなし=bytesデータのまま） midi_data_rx = uart_midi.read(1) except UnicodeError: # 読み込みエラーになるの？なら print("uart_midi.read(1) Error!!") midi_data_rx = "" # 受信データを２バイトの文字データにして追加保存する midi_rcvbuff += moji.byte2chr2(midi_data_rx) # MIDI受信が８秒以上なければ、mono_tone = 1 にする ############################################## monoTone_timer = MONOTONE_TIME ############################################## ######################################################################### # note on または note off のコマンドならば if ord(midi_data_rx) >= 0x80 and ord(midi_data_rx) <= 0x9F: note_Flag = 1 note_Byte = 1 prg_Flag = 0 status_Flag = 0 ch = ord(midi_data_rx) & 0x0F print(f'midi---> {midiMB}') midiMB = '' # midiモニターバッファ if sw_ch == 0: if ch == 0: pass else: uart_midi.write(midi_data_rx) # １バイトを２桁の文字に変換してmidiモニターバッファに追加する midiMB += moji.byte2chr2(midi_data_rx) # スワッピングが設定されていてコマンドなら sw_ch に変換して出力 else: if ch == 0: # ch == 0 なら sw_ch に変換して MIDI 出力 midi_data_tx = ord(midi_data_rx) & 0xF0 | sw_ch midi_data_tx = midi_data_tx.to_bytes(1, "big") uart_midi.write(midi_data_tx) # １バイトを２桁の文字に変換してmidiモニターバッファに追加する midiMB += moji.byte2chr2(midi_data_tx) elif ch == sw_ch: # ch == sw_ch なら MIDI 出力しない pass else: # それ以外なら そのまま MIDI 出力 uart_midi.write(midi_data_rx) # １バイトを２桁の文字に変換してmidiモニターバッファに追加する midiMB += moji.byte2chr2(midi_data_rx) # note on または note off のデータならば、データは２バイト elif ord(midi_data_rx) < 0x80 and note_Flag == 1: note_Byte += 1 if sw_ch == 0: if ch == 0: pass else: uart_midi.write(midi_data_rx) # １バイトを２桁の文字に変換してmidiモニターバッファに追加する midiMB += moji.byte2chr2(midi_data_rx) # スワッピングが設定されていてデータなら そのまま出力 else: if ch == sw_ch: # ch == sw_ch なら MIDI 出力しない pass else: # それ以外なら そのまま MIDI 出力 uart_midi.write(midi_data_rx) # １バイトを２桁の文字に変換してmidiモニターバッファに追加する midiMB += moji.byte2chr2(midi_data_rx) if note_Byte == 3: # データが3バイト目ならば、YMF825に出力する print(" >>> midi_rcvbuff = ", midi_rcvbuff) ##################################################### if mono_tone == 1: # mono_tone noteMonoToneYmf825(midi_rcvbuff) else: # MIDI受信した Program Change（音色変更）を利用する noteYmf825(midi_rcvbuff) ##################################################### # 次の受信の準備 note_Byte = 0 #################### midi_rcvbuff = "" note_Flag = 0 prg_Flag = 0 status_Flag = 0 #################### # Program Change（音色変更）のコマンドならば elif ord(midi_data_rx) >= 0xC0 and ord(midi_data_rx) <= 0xCF: mono_tone = 0 prg_Flag = 1 prg_Byte = 1 note_Flag = 0 status_Flag = 0 ch = ord(midi_data_rx) & 0x0F print(f'midi---> {midiMB}') midiMB = '' # midiモニターバッファ if sw_ch == 0: if ch == 0: pass else: uart_midi.write(midi_data_rx) # １バイトを２桁の文字に変換してmidiモニターバッファに追加する midiMB += moji.byte2chr2(midi_data_rx) # スワッピングが設定されていてコマンドなら sw_ch に変換して出力 else: if ch == 0: # ch == 0 なら sw_ch に変換して MIDI 出力 midi_data_tx = ord(midi_data_rx) & 0xF0 | sw_ch midi_data_tx = midi_data_tx.to_bytes(1, "big") uart_midi.write(midi_data_tx) # １バイトを２桁の文字に変換してmidiモニターバッファに追加する midiMB += moji.byte2chr2(midi_data_tx) elif ch == sw_ch: # ch == sw_ch なら MIDI 出力しない pass else: # それ以外なら そのまま MIDI 出力 uart_midi.write(midi_data_rx) # １バイトを２桁の文字に変換してmidiモニターバッファに追加する midiMB += moji.byte2chr2(midi_data_rx) # Program Change（音色変更）のデータならば elif ord(midi_data_rx) < 0x80 and prg_Flag == 1: prg_Byte += 1 if sw_ch == 0: if ch == 0: pass else: uart_midi.write(midi_data_rx) # １バイトを２桁の文字に変換してmidiモニターバッファに追加する midiMB += moji.byte2chr2(midi_data_rx) # スワッピングが設定されていてデータなら そのまま出力 else: if ch == sw_ch: # ch == sw_ch なら MIDI 出力しない pass else: # それ以外なら そのまま MIDI 出力 uart_midi.write(midi_data_rx) # １バイトを２桁の文字に変換してmidiモニターバッファに追加する midiMB += moji.byte2chr2(midi_data_rx) if prg_Byte == 2: print(" >>> midi_rcvbuff = ", midi_rcvbuff) ################################## # YMF825 用の ToneTable を更新する changeToneTable(midi_rcvbuff) ################################## # 次の受信の準備 prg_Byte = 0 #################### midi_rcvbuff = "" note_Flag = 0 prg_Flag = 0 status_Flag = 0 #################### # 0xBn 0xEn のコマンドならば、YMF825 に対しては何もせず。MIDI出力はする。 elif (ord(midi_data_rx) & 0xF0) == 0xB0 or (ord(midi_data_rx) & 0xF0) == 0xE0: status_Flag = 1 status_Byte = 1 note_Flag = 0 prg_Flag = 0 ch = ord(midi_data_rx) & 0x0F # print(f'ch = {ch} sw_ch = {sw_ch}') print(f'midi---> {midiMB}') midiMB = '' # midiモニターバッファ if sw_ch == 0: if ch == 0: pass else: uart_midi.write(midi_data_rx) # １バイトを２桁の文字に変換してmidiモニターバッファに追加する midiMB += moji.byte2chr2(midi_data_rx) # スワッピングが設定されていてコマンドなら sw_ch に変換して出力 else: if ch == 0: # ch == 0 なら sw_ch に変換して MIDI 出力 midi_data_tx = ord(midi_data_rx) & 0xF0 | sw_ch midi_data_tx = midi_data_tx.to_bytes(1, "big") uart_midi.write(midi_data_tx) # １バイトを２桁の文字に変換してmidiモニターバッファに追加する midiMB += moji.byte2chr2(midi_data_tx) elif ch == sw_ch: # ch == sw_ch なら MIDI 出力しない pass else: # それ以外なら そのまま MIDI 出力 uart_midi.write(midi_data_rx) # １バイトを２桁の文字に変換してmidiモニターバッファに追加する midiMB += moji.byte2chr2(midi_data_rx) # 0xBn 0xEn コマンドのデータならば、データは２バイト、全体で３バイト。 elif ord(midi_data_rx) < 0x80 and status_Flag == 1: status_Byte += 1 if sw_ch == 0: if ch == 0: pass else: uart_midi.write(midi_data_rx) # １バイトを２桁の文字に変換してmidiモニターバッファに追加する midiMB += moji.byte2chr2(midi_data_rx) # スワッピングが設定されていてデータなら そのまま出力 else: if ch == sw_ch: # ch == sw_ch なら MIDI 出力しない pass else: # それ以外なら そのまま MIDI 出力 uart_midi.write(midi_data_rx) # １バイトを２桁の文字に変換してmidiモニターバッファに追加する midiMB += moji.byte2chr2(midi_data_rx) # 0xBn 0xEn コマンドならば、３バイトである if status_Byte == 3: # データが3バイト目ならば、YMF825には出力せず # 次の受信の準備 status_Byte = 0 #################### midi_rcvbuff = "" note_Flag = 0 prg_Flag = 0 status_Flag = 0 #################### # その他の情報ならば、YMF825 に対しては何もせず。MIDI出力はする。 else: # MIDI 出力する uart_midi.write(midi_data_rx) # YMF825 に対しては何もしない #################### midi_rcvbuff = "" note_Flag = 0 prg_Flag = 0 status_Flag = 0 #################### elif monoTone_timer == 0: # MIDI受信が８秒以上なければ、mono_tone = 1 にする ############################################## mono_tone = 1 ############################################## # while uartRtsReq != 0 PicoMain から送信要求があれば中断する else: print('Recived uartRtsReq !') allNoteOff() uartRtsBusy = 1 return ####################################################################### # note off = 8n kk vv or 9n kk 00 note on = 9n kk vv # global tone_num で指定されているトーン番号＝PicoMainからのToneData # midi_rcvbuff から note on, note off 情報を抽出して ymf825に送る。 # midi Keyboard 入力で和音を出すために MONO TONE でチャンネルを振り分ける def noteMonoToneYmf825(midi_rcvbuff): # PicoMain から受信した tone_num で演奏する global tone_num print('noteKeyboardYmf825', end='') # ch = moji.asc2int(midi_rcvbuff[0:2]) % 16 kk = moji.asc2int(midi_rcvbuff[2:4]) & 0x7F vv = moji.asc2int(midi_rcvbuff[4:6]) & 0x7F # note off if midi_rcvbuff[0] == '8' or (midi_rcvbuff[0] == '9' and vv == 0): # ノート オン したチャンネルを探す ch = resetChList(kk) print(f' {ch} = index_ChList({kk})', end = '') if ch >= 0 and ch <= 16: print(f' note off ch = {ch}') ymf825.note_off(ch) else: pass # note on # 20240928 Edit elif midi_rcvbuff[0] == '9' and vv != 0: # 空きチャンネルを探す ch = setChList(kk) print(f' {ch} = index_ChList(0)', end = '') if ch >= 0 and ch <= 16: octave = int(kk / 12) -1 key = kk % 12 print(f' note on ch={ch} octave={octave} key={key} velocity={vv} tone={tone_num}') ymf825.note_onMonoTone(ch, octave, key, vv, tone_num) else: pass ####################################################################### # MIDI Keyboard からの入力を演奏する # Keyboardは、ch=0 だけなので、 MONO TONE にして和音対応する # PicoMain からの送信要求（uartRtsReq）があれば、中断する。 # 20240928 利用されていない def midiKeyboardPlayYmf825(): global uartRespR, uartRtsReq, uartRtsBusy midi_rcvbuff = "" note_Flag = 0 note_Byte = 0 prg_Flag = 0 prg_Byte = 0 status_Flag = 0 # チャンネルリストを 0 クリア initChList() # PicoMain から送信要求があれば中断する while uartRtsReq == 0: # MIDI 受信ありなら if uart_midi.any() > 0: try: # uart_midi から、１データ読み込む（decodeなし=bytesデータのまま） midi_data_rx = uart_midi.read(1) except UnicodeError: # 読み込みエラーになるの？なら print("uart_midi.read(1) Error!!") midi_data_rx = "" # 受信した１バイトを２バイトの文字に変換して、シリアル出力する # print(moji.byte2chr2(midi_data_rx), end="") # 受信データを２バイトの文字データにして追加保存する midi_rcvbuff += moji.byte2chr2(midi_data_rx) ######################################################################### # note on または note off ならば if ord(midi_data_rx) >= 0x80 and ord(midi_data_rx) <= 0x9F: note_Flag = 1 note_Byte = 1 prg_Flag = 0 status_Flag = 0 # note on または note off 情報情報ならば elif ord(midi_data_rx) < 0x80 and note_Flag == 1: note_Byte += 1 if note_Byte == 3: # データをシリアル出力する print(" >>> midi_rcvbuff = ", midi_rcvbuff) # ################################### # 20240705 Change # noteYmf825(midi_rcvbuff) noteMonoToneYmf825(midi_rcvbuff) ################################### note_Byte = 0 #################### midi_rcvbuff = "" note_Flag = 0 prg_Flag = 0 status_Flag = 0 #################### # Program Change（音色変更）ならば elif ord(midi_data_rx) >= 0xC0 and ord(midi_data_rx) <= 0xCF: prg_Flag = 1 prg_Byte = 1 note_Flag = 0 status_Flag = 0 # Program Change（音色変更）のデータならば elif ord(midi_data_rx) < 0x80 and prg_Flag == 1: prg_Byte += 1 if prg_Byte == 2: # ToneTable を更新する print(" >>> midi_rcvbuff = ", midi_rcvbuff) # ############################## # 20240705 Change # changeToneTable(midi_rcvbuff) ############################## prg_Byte = 0 #################### midi_rcvbuff = "" note_Flag = 0 prg_Flag = 0 status_Flag = 0 #################### # その他の情報ならば、何もしない else: #################### midi_rcvbuff = "" note_Flag = 0 prg_Flag = 0 status_Flag = 0 #################### # while uartRtsReq != 0 PicoMain から送信要求があれば中断する else: print('Recived uartRtsReq !') allNoteOff() uartRtsBusy = 1 return ######################################################################## # Aques Talk Ready Chexk def aquesReady(time, msg): global spi_timer spi_timer = time buff = bytearray(1) aques_cs.value(0) utime.sleep_us(100) spi1.readinto(buff, 0xFF) # 0xFF 送出して1byte 読み込む utime.sleep_us(100) aques_cs.value(1) while buff != '>': # > = Ready になるのを待つ if spi_timer == 0: print('Time Over spi_timer') return spi_timer else: # DEBUG print # print(msg, ' ', end='') # print(f'spi1.read(1) = {buff}') utime.sleep_ms(20) aques_cs.value(0) utime.sleep_us(100) spi1.readinto(buff, 0xFF) # 0xFF 送出して1byte 読み込む utime.sleep_us(100) aques_cs.value(1) return spi_timer ######################################################################## # Aques Talk 発声 # 末尾に改行（'\r'）を送るので、talk_buffは本文のローマ字だけで良い。 def aquesTalk(talk_buff): if len(talk_buff) > 0: print(talk_buff) # Aques Talk Ready Check cnt = aquesReady(2000, 'Wait Aques Talk Ready') if cnt > 0: aques_cs.value(0) utime.sleep_us(100) for i in range(len(talk_buff)): spi1.write(talk_buff[i]) utime.sleep_us(30) # byte間 20us以上 spi1.write(b'\r') utime.sleep_us(100) aques_cs.value(1) else: print('Error Aques Talk is not Ready in def aquesTalk(talk_buff):') ######################################################################## # Calculate the biquad filter parameters def on_calc_biquad_filter(flt_type, fc_num, qv_num): # Cut off frequency and Q value (fc Hz, YMF825 sampling frequency is always 48000 Hz) fc = float(fc_num) qv = float(qv_num) print(f'fc = {fc}, qx = {qv}') # Zero clear the Fc and Qv if fc < 0.0 or qv < 0.0: print('if fc < 0.0 or qv < 0.0: in def on_calc_biquad_filter(fc_num, qv_num)') return # Calculate the filter parameters if qv < 0.01: qv = 0.01 # print("BIQUAD FILTER:{}, Fc={}, Q={}".format(flt_type, fc, qv)) # 20240919 Change w0 = math.pi * 2 * fc / 48000 alpha = math.sin(w0) / (qv + qv) cosw0 = math.cos(w0) print(f'w0 = {w0}, alpha = {alpha}, cosw0 = {cosw0}') a0 = 1.0 + alpha a1 = cosw0 * 2 / a0 a2 = (alpha - 1.0) / a0 if flt_type == "LPF:FcQ": b0 = (1.0 - cosw0) / (a0 + a0) b1 = (1.0 - cosw0) / a0 b2 = b0 elif flt_type == "HPF:FcQ": b0 = (1.0 + cosw0) / (a0 + a0) b1 = -(1.0 + cosw0) / a0 b2 = b0 elif flt_type == "BPFskt:FcQ": b0 = qv * alpha / a0 b1 = 0 b2 = -b0 elif flt_type == "BPF0db:FcQ": b0 = alpha / a0 b1 = 0 b2 = -b0 elif flt_type == "NOTCH:FcQ": b0 = 1 / a0 b1 = -2 * cosw0 / a0 b2 = b0 elif flt_type == "APF:FcQ": b0 = (1 - alpha) / a0 b1 = -2 * cosw0 / a0 b2 = (1 + alpha) / a0 else: print("UNKNOWN FILTER TYPE.") return # Set parameters print(f'PARMS b0 = {b0}, b1 = {b1} , b2 = {b2}, a0 = {a0}, a1 = {a1}, a2 = {a2}') # return b0, b1, b2, a1, a2 ######################################################################## # FROM ymf825pico.py 757 line~ # Set equalizer # eql:: Equalizer number (0, 1, 2) # ceq#:: ceq-eql-# # def set_equalizer( self, eql, ceq0 = 1.0, ceq1 = 0.0, ceq2 = 0.0, ceq3 = 0.0, ceq4 = 0.0 ): def set_equalizer( eql, ceq0 = 1.0, ceq1 = 0.0, ceq2 = 0.0, ceq3 = 0.0, ceq4 = 0.0 ): # 20240920 Add global equalizer_ceq def decimal_to_binary(n: float, int_digits: int = 3, frac_digits: int = 20): """Convert a decimal number to its binary representation""" # Check if number is negative negative = n < 0 n = abs(n) # Separate the integer part and fractional part int_part = int(n) # 整数部 frac_part = n - int_part # 小数部 # Convert integer part to binary int_binary = bin(int_part).replace("0b", "") while len(int_binary) < int_digits: int_binary = "0" + int_binary # Convert fractional part to binary frac_binary = "" while frac_part > 0 and len(frac_binary) < frac_digits: frac_part *= 2 bit = int(frac_part) if bit == 1: frac_part -= bit frac_binary += "1" else: frac_binary += "0" # If the number is negative, perform two's complement if negative: binary = list(int_binary + frac_binary) for i, bit in enumerate(binary): binary[i] = '0' if bit == '1' else '1' # 1's complement for i in range(len(binary) - 1, -1, -1): # 2's complement if binary[i] == '1': binary[i] = '0' else: binary[i] = '1' break int_binary = "".join(binary[:int_digits]) frac_binary = "".join(binary[int_digits:]) # return f"{'1' if negative else '0'}{int_binary}{frac_binary}" return f"{'0b1' if negative else '0b0'}{int_binary}{frac_binary}" # Make CEQ# bytes data def make_ceq_bytes( ceq_num, ceq ): print(f'ceq_num = {ceq_num}') print(f'ceq = {ceq}') ######################################## ceqB = int(decimal_to_binary(ceq), 2) ######################################## print(f'{ceqB} = int(decimal_to_binary(ceq), 2)') print(f'{ceqB:b} = int(decimal_to_binary({ceq}))') print(f'type(ceqB) = {type(ceqB)}') equalizer_ceq[ceq_num *3 +0] = (ceqB & 0xFF0000) >> 16 # 上位8bit equalizer_ceq[ceq_num *3 +1] = (ceqB & 0x00FF00) >> 8 # 中位8bit equalizer_ceq[ceq_num *3 +2] = ceqB & 0x0000FF # 下位8bit print(f'equalizer_ceq = {equalizer_ceq}') print(f'len(equalizer_ceq) = {len(equalizer_ceq)}') print() # この関数の実行開始位置 # Clear CEQ bytes data for b in range(15): # # 20240920 Change # self.equalizer_ceq[b] = 0 equalizer_ceq[b] = 0 # Make CEQ0 bytes data make_ceq_bytes( 0, ceq0 ) make_ceq_bytes( 1, ceq1 ) make_ceq_bytes( 2, ceq2 ) make_ceq_bytes( 3, ceq3 ) make_ceq_bytes( 4, ceq4 ) # Burst write mode and all key notes off # print("EDITOR: YMF825 Burst write mode.") # # 20240920 Change # self.spi_write_byte( 0x08, 0xF6 ) # self.delay(20) # self.spi_write_byte( 0x08, 0x00 ) # ymf825.spi_write_single( 0x08, 0xF6 ) utime.sleep_ms(20) ymf825.spi_write_single( 0x08, 0x00 ) # # Write tone data to YMF825 FIFO. # print("EDITOR: Write sound data to YMF825.") # print("EQUALIZER", eql, ":", list(self.equalizer_ceq)) # # 20240920 Change # self.spi_write( 32 + eql, bytearray(list(self.equalizer_ceq)) ) # # ymf825.spi_write_multi( 32 + eql, bytearray(list(equalizer_ceq)) ) # ymf825.spi_write_multi( 32 + eql, equalizer_ceq ) ######################################################################## def domisoTest(): print('DoMiSo', 'Octave:4') ymf825.note_on(0, 4, ymf825.KEY_C, 40) utime.sleep_ms(1000) ymf825.note_on(1, 4, ymf825.KEY_E, 40) utime.sleep_ms(1000) ymf825.note_on(2, 4, ymf825.KEY_G, 40) utime.sleep_ms(1000) ymf825.note_off(0) ymf825.note_off(1) ymf825.note_off(2) ######################################################################## # ------------------------------------------------------------------------- # Python Main Program # ------------------------------------------------------------------------- # YMF825 Setting ymf825.setup() # Max = 63 # 指定しなければ Max = 63 のままのようだ。 # ymf825.set_MasterVolume(24) ymf825.set_MasterVolume(32) # ymf825.set_MasterVolume(40) # ymf825.set_MasterVolume(48) ymf825.init_tone() time.sleep(1) print('初期設定の音源で発音テスト（= ToneTable の登録に従って音出し）') domisoTest() # Ch0 スワッピング先の Ch 番号 # ポケット・ミクの音源を利用する場合、ミクの音声は出さない、または、GM音源としたい場合がある。 # ポケット・ミクの Ch0 の音声は、プログラム・チェンジ（楽器変更）に関係なく、ミクの音声になるので # これを回避するため、MIDI入力から Ch0 を sw_ch に変更して出力する。 # 0 なら 出力先なし = Play Mode With Out Ch0 と同じ・・・ミクの音声は出さない # 10（内部コード：9）はドラムなので sw_ch には指定しないのが無難。 sw_ch = 0 tone_num = 0 uartRtsReq = 0 # PicoMain からの送信要求 uartRtsBusy = 0 # UART COM RECIVE 実行中 # 'Ch0_Waon_Normal'：Ch0 は和音モードで動作するが、プログラムチェンジを受信するとMIDIのまま発音 play_mode = 'Ch0_Waon_Normal' play_mode_old = play_mode ############################################################################## # Main 直前で起動する Timer(period=10, callback=every10ms) ############################################################################## #---------------------------------------------------------------------------- # MicroPython Main Loop while True: # PicoMain からの受信があれば if uartRtsReq == 1 and uartRtsBusy == 1: play_mode_old = play_mode uartComRcv() # PicoMain からの受信処理 uartRtsBusy = 0 # UART COM RECIVE 実行終了 uartRtsReq = 0 # PicoMain からの送信要求 クリア # if play_mode.lower() == 'Init YMF825'.lower(): if 'Init'.lower() in play_mode.lower() and 'YMF'.lower() in play_mode.lower(): print('Init YMF825') ymf825.setup() # 指定しなければ Max = 63 のままのようだ。 ymf825.set_MasterVolume(32) ymf825.init_tone() time.sleep(1) print('初期設定の音源で発音テスト（= ToneTable の登録に従って音出し）') domisoTest() time.sleep(4) # 元の play_mode に戻す play_mode = play_mode_old # if play_mode.lower == 'All_Note_Off'.lower(): elif 'Note'.lower() in play_mode.lower() and 'Off'.lower() in play_mode.lower(): print('All Note Off') allNoteOff() sendAllNoteOffMidi() time.sleep(2) # 元の play_mode に戻す play_mode = play_mode_old # if play_mode.lower() == 'With Out Ch0'.lower(): elif 'With'.lower() in play_mode.lower() and 'Out'.lower() in play_mode.lower() \ and 'Ch0'.lower() in play_mode.lower(): print('With Out Ch0') sw_ch = 0 # 元の play_mode に戻す play_mode = play_mode_old # if play_mode.lower() == 'Swapping_Ch0_to >'.lower(): elif 'Swapping'.lower() in play_mode.lower() and 'Ch0'.lower() in play_mode.lower(): print('Swapping Ch0 to >') begin = 99 try: begin = play_mode.index('>') except ValueError: pass if begin < 14: sw_ch_old = sw_ch # > と space を取り除き、整数にする sw_ch = int(play_mode[begin:].strip('> ')) print(f'sw_ch = {sw_ch}') if sw_ch >= 0 and sw_ch <= 15: print(f'Swapping Ch0 to > {sw_ch}') else: sw_ch = sw_ch_old else: print('Irregular Swap Commands Ch ???') # 元の play_mode に戻す play_mode = play_mode_old # if play_mode.lower() == 'Ch0_Waon+4sec'.lower(): elif 'Waon'.lower() in play_mode.lower() and 'sec'.lower() in play_mode.lower(): print('play_mode = Ch0 Waon+4sec') # 元の play_mode に戻さない # if play_mode.lower() == 'Ch0_Waon+Normal'.lower(): elif 'Waon'.lower() in play_mode.lower() and 'Normal'.lower() in play_mode.lower(): print('play_mode = Ch0 Waon+Normal') # 元の play_mode に戻さない else: print('??? Unknown Commands') # 元の play_mode に戻す play_mode = play_mode_old # PicoMain からの受信がなければ else: ################################################################# # MIDI 受信・演奏をここに ・・・ midiPlayYmf825() # uartRtsReq == 1: PicoMain からの送信要求 あれば、処理を中断し、 # uartRtsBusy = 1: UART COM RECIVE 実行開始 をセットして戻る。 # 中断がない限り戻ってこない。 # Ch0 は、和音対応するが、MIDI信号にプログラムチェンジがあれば以降は # 和音対応せず、MIDI情報にしたがって発声する。 ################################################################# # if play_mode.lower() == 'Ch0_Waon+4sec'.lower(): if 'Waon'.lower() in play_mode.lower() and 'sec'.lower() in play_mode.lower(): print(f'play_mode = {play_mode}') print('midiPlayChaimeModeYmf825()') midiPlayChaimeModeYmf825() # play_mode_old = play_mode else: play_mode = 'Ch0 Waon Normal' print(f'play_mode = {play_mode}') print('midiPlayYmf825()') midiPlayYmf825() # play_mode_old = play_mode ''' aquesTalk("akuesu,to-ku,kido-simasita.") # 百人一首読み上げテスト aquesTalk("amanohara-,") aquesTalk("furisakemireba-,kasuganaru-,") aquesTalk("mikasanoyamani-,idesitukikamo-.") aquesTalk("a") aquesTalk("ma") aquesTalk("no") aquesTalk("ha") aquesTalk("ra,") aquesTalk("fu") aquesTalk("ri") aquesTalk("sa") aquesTalk("ke") aquesTalk("mi") aquesTalk("re") aquesTalk("ba,") aquesTalk("ka") aquesTalk("su") aquesTalk("ga") aquesTalk("na") aquesTalk("ru,") aquesTalk("mi") aquesTalk("ka") aquesTalk("sa") aquesTalk("no") aquesTalk("ya") aquesTalk("ma") aquesTalk("ni,") aquesTalk("i") aquesTalk("de") aquesTalk("si") aquesTalk("tu") aquesTalk("ki") aquesTalk("ka") aquesTalk("mo.") # Copy HectOnVoice to HectOne # Test 7 syu for i in range(8): # ローマ字 31文字文を連結する voiceRm = HectOneVoice[i][0] + \ HectOneVoice[i][1] + \ HectOneVoice[i][2] + \ HectOneVoice[i][3] + \ HectOneVoice[i][4] # 百人一首読み上げテスト aquesTalk(voiceRm) utime.sleep_ms(3000) equalizer_ceq = bytearray(15) ################################# # 以下は EQ（フィルター）テスト ################################# flt_type = 'LPF:FcQ' flt_fc = 1760 flt_qv = 0.7 # Calculate the biquad filter parameters (b0, b1, b2, a1, a2) = on_calc_biquad_filter(flt_type, flt_fc, flt_qv) # Set equalizer set_equalizer( 0, b0, b1, b2, a1, a2) utime.sleep_ms(1000) domisoTest() flt_type = 'HPF:FcQ' flt_fc = 440 flt_qv = 0.7 # Calculate the biquad filter parameters (b0, b1, b2, a1, a2) = on_calc_biquad_filter(flt_type, flt_fc, flt_qv) # Set equalizer set_equalizer( 1, b0, b1, b2, a1, a2) utime.sleep_ms(1000) domisoTest() flt_type = 'BPFskt:FcQ' flt_fc = 880 flt_qv = 0.7 # Calculate the biquad filter parameters (b0, b1, b2, a1, a2) = on_calc_biquad_filter(flt_type, flt_fc, flt_qv) # Set equalizer set_equalizer( 2, b0, b1, b2, a1, a2) utime.sleep_ms(1000) domisoTest() flt_type = 'LPF:FcQ' flt_fc = 1760 flt_qv = 0.7 # Calculate the biquad filter parameters (b0, b1, b2, a1, a2) = on_calc_biquad_filter(flt_type, flt_fc, flt_qv) # Set equalizer set_equalizer( 2, b0, b1, b2, a1, a2) utime.sleep_ms(1000) domisoTest() # Test Calculate the biquad filter parameters # on_calc_biquad_filter(flt_type, fc_num, qv_num) # (b0, b1, b2, a1, a2) = on_calc_biquad_filter("LPF:FcQ", 880, 4) flt_fc = 500.0 flt_qv = 0.7 for i in range(6): if i == 0: flt_type = 'LPF:FcQ' (b0, b1, b2, a1, a2) = on_calc_biquad_filter(flt_type, flt_fc, flt_qv) # Set equalizer Test set_equalizer( 0, b0, b1, b2, a1, a2) elif i == 1: flt_type = 'HPF:FcQ' (b0, b1, b2, a1, a2) = on_calc_biquad_filter(flt_type, flt_fc, flt_qv) # Set equalizer Test set_equalizer( 0, b0, b1, b2, a1, a2) elif i == 2: flt_type = 'BPFskt:FcQ' (b0, b1, b2, a1, a2) = on_calc_biquad_filter(flt_type, flt_fc, flt_qv) # Set equalizer Test set_equalizer( 0, b0, b1, b2, a1, a2) elif i == 3: flt_type = 'BPF0db:FcQ' (b0, b1, b2, a1, a2) = on_calc_biquad_filter(flt_type, flt_fc, flt_qv) # Set equalizer Test set_equalizer( 0, b0, b1, b2, a1, a2) elif i == 4: flt_type = 'NOTCH:FcQ' (b0, b1, b2, a1, a2) = on_calc_biquad_filter(flt_type, flt_fc, flt_qv) # Set equalizer Test set_equalizer( 0, b0, b1, b2, a1, a2) elif i == 5: # 【注意】強烈な音になる flt_type = 'APF:FcQ' (b0, b1, b2, a1, a2) = on_calc_biquad_filter(flt_type, flt_fc, flt_qv) # Set equalizer Test set_equalizer( 0, b0, b1, b2, a1, a2) utime.sleep_ms(1000) domisoTest() flt_type = 'LPF:FcQ' flt_fc = 5000.0 flt_qv = 0.7 # Calculate the biquad filter parameters (b0, b1, b2, a1, a2) = on_calc_biquad_filter(flt_type, flt_fc, flt_qv) # Set equalizer set_equalizer( 0, b0, b1, b2, a1, a2) utime.sleep_ms(1000) domisoTest() ''' ``` ### ymf825.py - 既出です・・・PicoMain側の ymf825.py と同じです。 ### mojipy.py - 既出です・・・PicoMain側の mojipy.py と同じです。  ## モジュールの紹介 ### 「touch_lcd.py」の改良について 「touch_lcd.py」は、LCD表示やタッチパネルからの入力を行うプログラムで、Waveshare社のサイトで提供されているサンプルプログラムmain_3inch5.pyを改変して「touch_lcd.py」としました。主に、「tone_edit.py」が利用します。 LCDの表示は４方向に指定できますが、表示を回転した時にも、表示座標（X軸・Y軸）とタッチ座標（X軸・Y軸）の方向が合致するように変更しました。表示位置のPixelと同様に扱えるようにしました。 タッチパネルのタッチ位置を表示位置に合わせて調整できるよう用のプログラムを内蔵・・・４隅にポイントを表示したところをタッチして、表示した結果でプログラムの定数を変更します。変更は自動ではなく、Thonyyでプログラムを書き換えが必要です。

「ymf825.py」は、FM音源IC YMF825を制御するための音源パラメータや制御コマンドを収納したモジュールです。 このモジュールは、Shunsuke Ohira様が作成されたプログラムやYAMAHAのＣ言語ライブラリなどを参考に作成しました。

「moji.py」は、①１バイトの整数を２バイトのASCII文字に変換 ②２バイト以上の0-9 a-f or A-F表記のASCII文字を整数に変換 するためのモジュールです。シリアル通信するときのデータのパックやアンパックに利用していますが、bytearrayの使い方がよく分かっていなかった時に作ったモジュールです。bytearrayをうまく使えば不要にできると思いますがプログラムを書き換えるのが面倒なのでそのままにしています。  # プログラムの動かし方（読み飛ばし可） PicoでMicroPythonプログラムを動かす方法は、①Thonnyで開いているプログラムを実行させる。②Picoにmain.pyの名前で書き込んで実行する。の２つの方法があります。 どちらにしてもmain.pyプログラム以外のモジュールである「touch_lcd.py」や「tone_edit.py」などは、予めPicoに書き込んでおく必要があります。  # YMF825パラメータの紹介（読み飛ばし可） - ご参考に編集対象である、YMF825のパラメータについて紹介します - YMF825では、16種類の音源を設定できます。 - 各音源の音色は、ベースの高さ(BO)、音の揺れ(LFO)、アルゴリズム(ALG)の3つに、17種類のパラメータをもつ4オペレータ(68パラメータ)を加えた全71パラメータで決定します。 - 4オペレータには、SR、XOF、KSR、RR、DR、AR、SL、TL、KSL、DAM、EAM、DVB、EVB、MUL、DT、WS、FBの17要素があります。 - 例えば、YAMAHAが用意しているTone Number 11 NylonGuiter は、次のようなパラメータになっています。 |Common Parameter|Max|Now| |:--------------:|:----:|:----:|:---:|:---:| |BO|3|0| |LFO|3|2| |ARG|7|5| |Parameter|Max|op1|op2|op3|op4| |:--------------:|:----:|:----:|:---:|:---:|:---:|:---:| |SR| 15| 1| 3| 5| 4| |XOF| 1| 0| 0| 0| 0| |KSR| 1| 1| 0| 1| 0| |RR| 15| 4| 7| 5| 9| |DR| 15| 1| 3| 5| 4| |AR| 15| 14| 15| 11| 13| |SL| 15| 8| 15| 4| 15| |TL| 63| 21| 0| 14| 13| |KSL| 3| 1| 0| 0| 2| |DAM| 3| 0| 0| 0| 0| |EAM| 1| 0| 0| 0| 0| |DVB| 3| 0| 0| 0| 1| |EVB| 1| 0| 1| 0| 1| |MUL| 15| 1| 1| 3| 1| |DT| 7| 0| 0| 0| 0| |WS| 31| 0| 0| 0| 0| |FB| 7| 6| 0| 0| 0| Maxは、YMF825が、項目別に設定できる最大値です。  # 編集画面の紹介 YMF825では、16の音源毎に共通項である3要素（BO、LFO、ALG）の編集画面と、4オペレータ17要素（SR、XOF、KSR、RR、DR、AR、SL、TL、KSL、DAM、EAM、DVB、EVB、MUL、DT、WS、FB）について編集する必要があります。 以下、編集画面を紹介します。 編集の操作状況は、Facebookに紹介動画があります。 Facebookに紹介動画があります。（Facebookへのログインが必要です） https://www.facebook.com/toshikazu.hyodo/videos/1216092900384973?idorvanity=247733226639836  ## ALG（Algorithm）選択画面  CIMG9075.JPG - ALG（Algorithm）：アルゴリズムは、４つのオペレータをどのような組み合わせるかの選択です。 - YMF825の場合、７つのアルゴリズムがありますので、組み合わせのイメージを表示して、その番号部分をタッチして選択できるようにしました。 ## BO、LFO 選択画面  CIMG9076.JPG - 音源のベースの高さ(BO)を設定します。通常は「0」ですが、低い方に１オクターブ、２オクターブ、３オクターブを選択できるようになっています。 - 音の揺れ(LFO)は、オシレータの周波数を選択できます。４つのオペレータのDAM、EAM、DVB、EVBと関係があると思います。 ## WS（Wave Shapes）選択画面  CIMG9077.JPG WS（Wave Shapes）：音源の波形の選択では、29の波形をイメージ表示してそれをタッチ選択するようにしました。 ## ADSR編集画面  CIMG9086.JPG - ADSR編集画面では、AR、DR、SR、RR、TL、SL、KSL、KSRを、１つの画面で編集しようとするものです。 - これらの要素は、４つのオペレータごとに設定する必要がありますので、画面上半分にある「OP1」～「OP4」で、どのオペレータに対する編集かを選択する必要があります。 - WSとMULは関連が深いので参考に表示しています。 - グラフの偏移点に紫色で四角のポイントが４つあります。ここにタッチペンを当てると大きなポイント表示となり、そのポイントを緑色の直線状、または、黄色の四角や緑色の四角の範囲内でスライドさせることで値を設定できます。 - ARとTL、DRとSRについては相互に関連していますので、黄色の四角と緑色の四角の範囲内で両方を同時に設定できるようにしています。 - KSL、KSRは、段階的な設定値を選ぶようになっています。設定値の場所をタッチするとその設定に切り替わり背景色と文字色が変わります。  ## MUL、DT、FB、XOF 編集画面  CIMG9081.JPG - この画面では、MUL、DT、FB、XOFを設定する画面です。 - これらの要素は、４つのオペレータごとに設定する必要がありますので、画面上半分にある「OP1」～「OP4」でオペレータを選択する必要があります。 - WSとMULは関連が深いので参考に表示しています。 - MULとDTは、緑の直線状に紫色で四角のポイントがあります。ここにタッチペンを当てると大きなポイント表示となり、そのポイントを緑色の直線状にスライドさせることで値を設定できます。 - FB、XOFは、段階的な設定値を選ぶようになっています。設定値の場所をタッチすると、その設定に切り替わり背景色と文字色が変わります。  ## DAM、EAM、DVB、EVB、編集画面  CIMG9089.JPG DAM、EAM、DVB、EVBの選択画面です。 LFOの設定と関係があるようです。  # おまけ - 他人が作ったプログラムを見る（読む）には大変です。特に素人の私が作った長く絡まりまくったスパゲッティのようなプログラムを見るのは苦行だと思います。 - そこで最後までご覧いた方に、おまけを用意しました。 - このプログラムの実行には touch_lcd.py が必要です。touch_lcd.pyは既出です。 - Pico-ResTouch-LCD-3.5の背面にある40PinのPico用のソケットにPimoroni Pico Plus2 または Raspberry Pi Pico2を装着するだけで、PicoSubとの接続は無しで編集画面だけの確認ができます。  CIMG9113_4-3コメント.jpg ## TestEditMul_main.py 上記回路で確認できる MUL、DT、FB、XOFの設定部分だけをコンパクトにまとめたプログラムです。 ```MicroPython:TestEditMul_main.py ######################################################################## # 2025/11/30 Programed by Hyodot # TestEditMUL.py # このプログラムを Pico に保存して起動するときはファイル名を main.py にしてください。 # このプログラムはLCDタッチパネル Waveshare社製 Pico-ResTouch-LCD-3.5 を利用して # MUL DT FB XOF というパラメータ編集だけに限定した、体験用プログラムです。 ######################################################################## # # このプログラムでは、Pico-ResTouch-LCD-3.5 を利用するために # touch_lcd.py # を必要とします。 # touch_lcd.py は、Waveshare社が用意しているサンプルプログラム # main_3inch5.py をベースにライブラリとして利用できるように改変したものです。 # touch_lcd.py は Micropython の FrameBufferを利用します。 # １画面分では、320 ☓ 480 Pixel ☓ 2 Bytes = 307200 Bytes のメモリを必要です。 # Pimoroni Pico Plus2 のメモリは、PSRAM 8MB ・・・ 動作します # Raspberry Pi Pico2 のメモリは、SRAM 520KB ・・・ 動作します # Raspberry Pi Pico のメモリは、SRAM 264KB ・・・ 動作しません # このプログラムは Pimoroni Pico Plus2 および Raspberry Pi Pico2 で動作しますが # メモリの少ない Raspberry Pi Pico では動作しません。 # # Pico-ResTouch-LCD-3.5 の背面にある Pico取り付け用のソケットに # Pimoroni Pico Plus2 または Raspberry Pi Pico2 を装着するだけで動作します。 # # Raspberry Pi Pico2 では、SPIの周波数が 40MHz で動作しますが、 # Pimoroni Pico Plus2 は、40MHz で動作させると嵌まり込む症状が出ます。 # PSRAM の特性で速度の問題があるのかもしれません。20MHzなら動作します。 # 理由はわかりませんが、SPI の実行速度は、設定した周波数の６割で動作しています。 # ######################################################################## from machine import Pin, SPI, PWM from micropython import const import os import gc # メモリ利用状況表示用 from touch_lcd import LCD_3inch5 ######################################################################## print(f'main MicroPython Start ... gc.mem_alloc() = {gc.mem_alloc()}') ######################################################################## ################################################## # import した ライブラリ class の短縮名 LCD = LCD_3inch5() LCD.bl_ctrl(100) # LCD輝度 100% 変更可能です print(f'LCD.rotate = {LCD.rotate}') ################################################## # タッチの誤動作を防止するためゾーンを複数回タッチした時に反応するようにしました。 # ここで設定した回数を連続して検知した時に受け付ける。３回にしました。 TOUCH_TH = const(3) # この Pixel 分を上下左右に拡大したエリアをタッチ有効とする。 # パネルの周辺部分では誤差が多いので、一部はこの倍の領域にしています。 TOUCH = const(8) # 表示座標 UPys = const(24) LWys = const(264) UPzs = [0, UPys] LWzs = [0, LWys] # 開始座標 幅 高さ UpperAria = (UPzs, 320, 240-24) LowerAria = (LWzs, 320, 240-24) # 編集テスト用パラメータ・データ # このプログラムでは、一部のパラメータの編集のみですが、すべてのパラメータを掲載します。 # 音源番号（ToneNo）は、0~15 ありますが、0:Grand Pianoのパラメータです。 # YMF825 Grand Piano Tone Data Set # ToneNo 0-15 TN = 0 max_TN = const(15) # Common BO = 0 LFO = 1 ALG = 3 max_BO = const(3) max_LFO = const(3) max_ALG = const(7) # Operator # 以下は、オペレーション・パラメータで、それぞれ４つのオペレータがある。 # 0:Max,op1,op2,op3,op4 を OP_numで指定する。 # 0:Max 1 2 3 4 WS = [31, 8, 0, 0, 0] MUL = [15, 1, 5, 1, 1] DT = [ 7, 0, 0, 0, 0] FB = [ 7, 0, 0, 0, 0] XOF = [ 1, 0, 0, 0, 0] TL = [63,39,40,34, 0] # YMF825 は 63 だが 実用的に 48 とする SL = [15,15, 2, 3, 4] AR = [15,15,14,13,13] DR = [15, 7, 3, 1, 2] SR = [15, 0, 2, 1, 2] RR = [15, 6, 3, 4, 6] KSL = [ 3, 1, 3, 0, 2] KSR = [ 1, 0, 1, 0, 1] DAM = [ 3, 0, 0, 0, 0] EAM = [ 1, 0, 0, 0, 0] DVB = [ 3, 0, 0, 0, 0] EVB = [ 1, 0, 0, 1, 1] # Operator は４つありますが、ここでは１番目のパラメータのみを編集対象にします。 OP_num = 1 now_WS = WS[OP_num] now_MUL = MUL[OP_num] now_DT = DT[OP_num] now_FB = FB[OP_num] now_XOF = XOF[OP_num] now_TL = TL[OP_num] now_SL = SL[OP_num] now_AR = AR[OP_num] now_DR = DR[OP_num] now_SR = SR[OP_num] now_RR = RR[OP_num] now_KSL = KSL[OP_num] now_KSR = KSR[OP_num] now_DAM = DAM[OP_num] now_EAM = EAM[OP_num] now_DVB = DVB[OP_num] now_EVB = EVB[OP_num] OP_max = const(0) max_WS = WS[OP_max] max_MUL = MUL[OP_max] max_DT = DT[OP_max] max_FB = FB[OP_max] max_XOF = XOF[OP_max] max_TL = TL[OP_max] -15 # 48 に抑制 max_SL = SL[OP_max] max_AR = AR[OP_max] max_DR = DR[OP_max] max_SR = SR[OP_max] max_RR = RR[OP_max] max_KSL = KSL[OP_max] max_KSR = KSR[OP_max] max_DAM = DAM[OP_max] max_EAM = EAM[OP_max] max_DVB = DVB[OP_max] max_EVB = EVB[OP_max] # X_Poin と Y_Point が 共に zoneS ~ zoneE の範囲内にあるか否か def in_zone(zoneS, zoneE, X_Point, Y_Point): # X_Poin と Y_Point が 共に zoneS ~ zoneE の範囲内ならば True if zoneS[0] <= X_Point and X_Point <= zoneE[0] \ and zoneS[1] <= Y_Point and Y_Point <= zoneE[1]: return True else: return False def dspFillUpper(color_back): (zs, w, h) = UpperAria LCD.fill_rect(zs[0], zs[1], w, h, color_back) def dspFillLower(color_back): (zs, w, h) = LowerAria LCD.fill_rect(zs[0], zs[1], w, h, color_back) def dspMUL(now_MUL): # MUL 数値表示 文字領域を 白色にしてから表示 LCD.fill_rect(8, 270, 16*4, 20, LCD.WHITE) LCD.text_scaled(f'{now_MUL:>2}', 24, 270 +2, LCD.BLACK, 2) # 右寄せ表示 def dspDT(now_DT): # DT 数値表示 文字領域を 白色にしてから表示 LCD.fill_rect(80+16, 340, 16*3, 20, LCD.WHITE) LCD.text_scaled(f'{now_DT}', 80+32, 340+2, LCD.BLACK, 2) def dsp_FB(now_FB, color_back, color_text): # FB 数値表示 背景を黄色にし、文字色は紫色 # 0 1 2 3 4 5 6 7 text_FB = [' 0 ', 'pi/16', 'pi/ 8', 'pi/ 4', 'pi/ 2', 'pi ', 'pi *2', 'pi *4'] if now_FB >= 0 and now_FB <= 7: LCD.fill_rect(FBxs[now_FB]-2, FBys[now_FB], 16*FBcn +4, 20, color_back) LCD.text_scaled(text_FB[now_FB], FBxs[now_FB], FBys[now_FB]+2, color_text, 2) def dsp_XOF(now_XOF, color_back, color_text): # XOF 数値表示 背景を黄色にし、文字色は紫色 # 0 1 text_XOF = ['off', 'on '] if now_XOF >= 0 and now_XOF <= 1: LCD.fill_rect(XOFxs[now_XOF]-2, XOFys[now_XOF], 16*XOFcn +4, 20, color_back) LCD.text_scaled(text_XOF[now_XOF], XOFxs[now_XOF], XOFys[now_XOF]+2, color_text, 2) ######################################################################## # MicroPython Start ######################################################################## # sign_XX は、スライダーの正負（X軸、Y軸の移動に対して取得数値が増大か？縮小か？） # MUL DT ともに上が大、下が小なので、-1 sign_MUL = -1 sign_DT = -1 # FB タッチ開始座標の設定 # 0 1 2 3 4 5 6 7 FBxs = [160,160,160,160,160,160,160,160] FBys = [430,410,390,370,350,330,310,290] FBcn = 5 # XOF タッチ開始座標の設定 # 0 1 XOFxs = [250,250] XOFys = [430,410] XOFcn = 3 # 編集メモ tone_edit.py の関数 # def edit_mul(tabM_num, tabS_num, OP_num, now_MUL, now_DT, now_FB, now_XOF): # から主要部分を移植した。 # FB タッチゾーンの設定 # FB タッチ開始座標は、main で設定したものを利用する zone_FBsi = [None, None] *(max_FB +1) zone_FBei = [None, None] *(max_FB +1) for i in range(max_FB +1): zone_FBsi[i] = [FBxs[i], FBys[i]] zone_FBei[i] = [FBxs[i]+16*6, FBys[i]+20] # FB カウンタの設定 cnt_FBi = [None] *(max_FB +1) for i in range(max_FB +1): cnt_FBi[i] = 0 # XOF タッチゾーンの設定 # XOF タッチ開始座標は、冒頭で設定したものを利用する zone_XOFsi = [None, None] *(max_XOF +1) zone_XOFei = [None, None] *(max_XOF +1) for i in range(max_XOF +1): zone_XOFsi[i] = [XOFxs[i], XOFys[i]] zone_XOFei[i] = [XOFxs[i]+16*6, XOFys[i]+20] # XOF カウンタの設定 cnt_XOFi = [None] *(max_XOF +1) for i in range(max_XOF +1): cnt_XOFi[i] = 0 # MUL DT スライダーポイントの座標設定（Pixcel単位）：絶対値 pos_MUL = [ 40, 445 - now_MUL *10] # MUL:0~15 pos_DT = [120, 445 - now_DT *10] # DT:0~7 # MUL DT カウンタの設定 cnt_MUL = 0 cnt_DT = 0 # MUL DT タッチゾーン設定 16 Pixcel四方 ---> 24 Pixcel四方 zone_MULs = [None] *2 zone_MULs[0] = 0 if pos_MUL[0] < TOUCH *2 else pos_MUL[0] - TOUCH *2 zone_MULs[1] = 0 if pos_MUL[1] < TOUCH *2 else pos_MUL[1] - TOUCH *2 zone_MULe = [None] *2 zone_MULe[0] = 319 if (pos_MUL[0] + TOUCH) >= 320 else pos_MUL[0] + TOUCH zone_MULe[1] = 479 if (pos_MUL[1] + TOUCH) >= 480 else pos_MUL[1] + TOUCH zone_DTs = [None] *2 zone_DTs[0] = 0 if pos_DT[0] < TOUCH *2 else pos_DT[0] - TOUCH *2 zone_DTs[1] = 0 if pos_DT[1] < TOUCH *2 else pos_DT[1] - TOUCH *2 zone_DTe = [None] *2 zone_DTe[0] = 319 if (pos_DT[0] + TOUCH) >= 320 else pos_DT[0] + TOUCH zone_DTe[1] = 479 if (pos_DT[1] + TOUCH) >= 480 else pos_DT[1] + TOUCH ######################################################################## # MUL 直線上の設定範囲（Pixcel単位）：絶対値 slide_MULs = [ 40, 445 - max_MUL *10] slide_MULe = [ 40, 445] # DT 直線上の設定範囲（Pixcel単位）：絶対値 slide_DTs = [120, 445 - max_DT *10] slide_DTe = [120, 445] # 長方形の操作可能範囲 16 Pixcel guide_MULs = [None] *2 guide_MULs[0] = 0 if slide_MULs[0] < TOUCH *2 else slide_MULs[0] - TOUCH *2 guide_MULs[1] = 0 if slide_MULs[1] < TOUCH else slide_MULs[1] - TOUCH guide_MULe = [None] *2 guide_MULe[0] = 319 if (slide_MULe[0] + TOUCH) >= 320 else slide_MULe[0] + TOUCH guide_MULe[1] = 479 if (slide_MULe[1] + TOUCH) >= 480 else slide_MULe[1] + TOUCH guide_DTs = [None] *2 guide_DTs[0] = 0 if slide_DTs[0] < TOUCH *2 else slide_DTs[0] - TOUCH *2 guide_DTs[1] = 0 if slide_DTs[1] < TOUCH else slide_DTs[1] - TOUCH guide_DTe = [None] *2 guide_DTe[0] = 319 if (slide_DTe[0] + TOUCH) >= 320 else slide_DTe[0] + TOUCH guide_DTe[1] = 479 if (slide_DTe[1] + TOUCH) >= 480 else slide_DTe[1] + TOUCH edt_mode = '' while True: # MUL DT 座標更新 # MUL DT スライダーポイントの座標設定（Pixcel単位）：絶対値 pos_MUL = [ 40, 445 - now_MUL *10] # MUL:0~15 pos_DT = [120, 445 - now_DT *10] # DT:0~7 # MUL DT タッチゾーン更新 16 Pixcel四方 ---> 24 Pixcel四方 # pos_MUL と pos_DT は、タッチで更新される zone_MULs[0] = 0 if pos_MUL[0] < TOUCH *2 else pos_MUL[0] - TOUCH *2 zone_MULs[1] = 0 if pos_MUL[1] < TOUCH *2 else pos_MUL[1] - TOUCH *2 zone_MULe[0] = 319 if (pos_MUL[0] + TOUCH) >= 320 else pos_MUL[0] + TOUCH zone_MULe[1] = 479 if (pos_MUL[1] + TOUCH) >= 480 else pos_MUL[1] + TOUCH zone_DTs[0] = 0 if pos_DT[0] < TOUCH *2 else pos_DT[0] - TOUCH *2 zone_DTs[1] = 0 if pos_DT[1] < TOUCH *2 else pos_DT[1] - TOUCH *2 zone_DTe[0] = 319 if (pos_DT[0] + TOUCH) >= 320 else pos_DT[0] + TOUCH zone_DTe[1] = 479 if (pos_DT[1] + TOUCH) >= 480 else pos_DT[1] + TOUCH dspFillUpper(LCD.WHITE) dspFillLower(LCD.WHITE) # 画面全体を白色にしたい場合 # LCD.fill(LCD.WHITE) # slide Line 垂直方向のガイド（垂直方向に５回線を引く） # MUL DT for x in range(-2, 3): # -2, -1, 0, 1, 2 : 38, 39, 40, 41, 42 : 118, 119, 120, 121, 122 LCD.line(slide_MULs[0]+x, slide_MULs[1], slide_MULe[0]+x, slide_MULe[1]+4, LCD.GREEN) LCD.line(slide_DTs[0]+x, slide_DTs[1], slide_DTe[0]+x, slide_DTe[1]+4, LCD.GREEN) # MUL DT の操作ポイントを、サイズ TOUCH（8x8）で再表示する LCD.fill_rect(pos_MUL[0] -4, pos_MUL[1] -4, TOUCH, TOUCH, LCD.RED) LCD.fill_rect(pos_DT[0] -4, pos_DT[1] -4, TOUCH, TOUCH, LCD.RED) # MUL のタイトル表示 LCD.text_scaled(f'MUL', 0 +16, 455, LCD.BLACK, 2) # DT のタイトル表示 LCD.text_scaled(f'DT', 80 +24, 455, LCD.BLACK, 2) # MUL DT の数値を表示する（編集中にも表示することに留意） dspMUL(now_MUL) dspDT(now_DT) # FB のタイトル表示 LCD.text_scaled(f'FB', 160+24, 455, LCD.BLACK, 2) # FB 数値表示 文字領域を 緑色にしてから表示、文字色は一旦灰色 for fb in range(max_FB +1): # FB 設定内容の表示 dsp_FB(fb, LCD.GREEN, LCD.GRAY) # FB 設定値の表示 dsp_FB(now_FB, LCD.YELLOW, LCD.PURPLE) # XOF のタイトル表示 LCD.text_scaled(f'XOF',250, 455, LCD.BLACK, 2) # XOF 数値表示 文字領域を 緑色にしてから表示、文字色は一旦灰色 for xof in range(max_XOF +1): # XOF 設定内容の表示 dsp_XOF(xof, LCD.GREEN, LCD.GRAY) # XOF 設定値の表示 dsp_XOF(now_XOF, LCD.YELLOW, LCD.PURPLE) get = LCD.touch_get() if get != None: # タッチされているなら、X座標、Y座標を取得します X_Point = get[0] Y_Point = get[1] if edt_mode == '': if in_zone(zone_MULs, zone_MULe, X_Point, Y_Point): # MUL ポイント周辺ならば # print('zone_MUL') cnt_MUL += 1 if cnt_MUL == TOUCH_TH: print('select_MUL') # 差分検出用に現在値を記録（Pixcel値） edt_Ys = Y_Point edt_mode = 'MUL' elif in_zone(zone_DTs, zone_DTe, X_Point, Y_Point): # DT ポイント周辺ならば # print('zone_DT') cnt_DT += 1 if cnt_DT == TOUCH_TH: print('select_DT') # 差分検出用に現在値を記録（Pixcel値） edt_Ys = Y_Point edt_mode = 'DT' for i in range(max_FB +1): if in_zone(zone_FBsi[i], zone_FBei[i], X_Point, Y_Point): # print(f'zone_FB{i}') cnt_FBi[i] += 1 if cnt_FBi[i] == TOUCH_TH: # 差分検出用に現在値を記録（Pixcel値） edt_Xs = X_Point edt_Ys = Y_Point now_FB = i # FB 数値表示 背景を黄色にし、文字色は紫色 dsp_FB(now_FB, LCD.YELLOW, LCD.PURPLE) edt_mode = f'FB{i}' print(f'edt_mode = {edt_mode}') for i in range(max_XOF +1): if in_zone(zone_XOFsi[i], zone_XOFei[i], X_Point, Y_Point): # print(f'zone_XOF{i}') cnt_XOFi[i] += 1 if cnt_XOFi[i] == TOUCH_TH: # 差分検出用に現在値を記録（Pixcel値） edt_Xs = X_Point edt_Ys = Y_Point now_XOF = i # XOF 数値表示 背景を黄色にし、文字色は紫色 dsp_XOF(now_XOF, LCD.YELLOW, LCD.PURPLE) edt_mode = f'XOF{i}' print(f'edt_mode = {edt_mode}') elif edt_mode == 'MUL': if in_zone(guide_MULs, guide_MULe, X_Point, Y_Point): # MUL 編集ゾーンならば # print('edt_mode MUL') if edt_Ys != Y_Point: # 操作感度を上げる場合は、/4 の数字を小さく、下げる場合は、/4 の数字を大きく # edt_def = int((Y_Point - edt_Ys) /4) edt_def = int((Y_Point - edt_Ys) /8) # 加減算の正負に注意（x軸は右方向に正、y軸は下方向に正） now_MUL += (edt_def *sign_MUL) # 範囲に収める処理 now_MUL = 0 if now_MUL < 0 else now_MUL now_MUL = max_MUL if now_MUL > max_MUL else now_MUL # 表示ポイント更新 計算方法は項目ごとに異なるので注意 # スライダーポイントの座標設定（Pixcel単位）：絶対値 を更新 pos_MUL = [ 40, 445 - now_MUL *10] # MUL:0~15 # MUL の操作ポイントを、倍角 TOUCH（8x8）*2 で表示する LCD.fill_rect(pos_MUL[0] -TOUCH, pos_MUL[1] -TOUCH, TOUCH*2, TOUCH*2, LCD.PURPLE) # MUL 数値表示 文字領域を 白色にしてから表示 dspMUL(now_MUL) # edt_Ys 更新 edt_Ys = pos_MUL[1] elif edt_mode == 'DT': if in_zone(guide_DTs, guide_DTe, X_Point, Y_Point): # DT 編集ゾーンならば # print('edt_mode DT') if edt_Ys != Y_Point: # 操作感度を上げる場合は、/4 の数字を小さく、下げる場合は、/4 の数字を大きく # edt_def = int((Y_Point - edt_Ys) /4) edt_def = int((Y_Point - edt_Ys) /8) # 加減算の正負に注意（x軸は右方向に正、y軸は下方向に正） now_DT += (edt_def *sign_DT) # 範囲に収める処理 now_DT = 0 if now_DT < 0 else now_DT now_DT = max_DT if now_DT > max_DT else now_DT # 表示ポイント更新 計算方法は項目ごとに異なるので注意 # スライダーポイントの座標設定（Pixcel単位）：絶対値 pos_DT = [120, 445 - now_DT *10] # DT:0~7 # DT の操作ポイントを、倍角 TOUCH（8x8）*2 で表示する LCD.fill_rect(pos_DT[0] -TOUCH, pos_DT[1] -TOUCH, TOUCH*2, TOUCH*2, LCD.PURPLE) # DT 数値表示 文字領域を 白色にしてから表示 dspDT(now_DT) # edt_Ys 更新 edt_Ys = pos_DT[1] else: # get == None edt_mode = '' # MUL DT カウンタのクリア cnt_MUL = 0 cnt_DT = 0 # FB カウンタのクリア for i in range(max_FB +1): cnt_FBi[i] = 0 # XOF カウンタのクリア for i in range(max_XOF +1): cnt_XOFi[i] = 0 LCD.show() ``` **最後までご覧いただきありがとうございます。何かの参考になれば幸いです。**