diff --git a/.gitignore b/.gitignore index 8168573..e3bd7e5 100644 --- a/.gitignore +++ b/.gitignore @@ -66,3 +66,4 @@ GUI /software/raspberry/testeur/testeur/build/ /software/raspberry/testeur/testeur/dist/ /software/dumber3/Debug/ +/software/dumber3/Tests/ diff --git a/hardware/pcb/Dumber-v3/dumber-v3/dumber-v3-bom.pdf b/hardware/pcb/Dumber-v3/dumber-v3/dumber-v3-bom.pdf new file mode 100644 index 0000000..5768932 Binary files /dev/null and b/hardware/pcb/Dumber-v3/dumber-v3/dumber-v3-bom.pdf differ diff --git a/hardware/pcb/Dumber-v3/dumber-v3/dumber-v3.csv b/hardware/pcb/Dumber-v3/dumber-v3/dumber-v3.csv new file mode 100644 index 0000000..927caca --- /dev/null +++ b/hardware/pcb/Dumber-v3/dumber-v3/dumber-v3.csv @@ -0,0 +1,52 @@ +"Source:","/home/dimercur/Travail/git/dumber/hardware/pcb/Dumber-v3/dumber-v3/dumber-v3.kicad_sch" +"Date:","lun. 04 sept. 2023 10:56:20" +"Tool:","Eeschema 7.0.7" +"Generator:","/app/share/kicad/plugins/bom_csv_grouped_by_value.py" +"Component Count:","70" + +"Collated Components:" + +"Item","Qty","Reference(s)","Value","LibPart","Footprint","Datasheet","DNP" +"1","1","BT1","Li-ION","Device:Battery_Cell","INSA:Battery-14500","~","" +"2","2","C1, C4","10nF","Device:C","Capacitor_SMD:C_0805_2012Metric","~","" +"3","1","C2","68nF","Device:C","Capacitor_SMD:C_0805_2012Metric","~","" +"4","1","C3","100µF","Device:C","Capacitor_SMD:C_1210_3225Metric","~","" +"5","1","C5","2.2µF","Device:C","Capacitor_SMD:C_0805_2012Metric","~","" +"6","2","C6, C11","10µF","Device:C","Capacitor_SMD:C_0805_2012Metric","~","" +"7","4","C7, C12, C13, C22","1µF","Device:C","Capacitor_SMD:C_0805_2012Metric","~","" +"8","1","C8","650pF","Device:C","Capacitor_SMD:C_0805_2012Metric","~","" +"9","1","C9","100pF","Device:C","Capacitor_SMD:C_0805_2012Metric","~","" +"10","1","C10","10µF","Device:C","Capacitor_SMD:C_1210_3225Metric","~","" +"11","2","C14, C15","470nF","Device:C","Capacitor_SMD:C_0805_2012Metric","~","" +"12","4","C16, C17, C18, C19","100nF","Device:C","Capacitor_SMD:C_0805_2012Metric","~","" +"13","1","C21","1nF","Device:C","Capacitor_SMD:C_0805_2012Metric","~","" +"14","1","D1","PMEG2020CPA","Device:D_Dual_CommonCathode_AAK_Parallel","INSA:Nexperia_SOT-1061","~","" +"15","1","D2","FM5818-W","Device:D_Schottky","Diode_SMD:D_SMA","~","" +"16","3","H1, H2, H3","MountingHole","Mechanical:MountingHole","MountingHole:MountingHole_3.2mm_M3_ISO14580","~","" +"17","2","J1, J2","Conn_02x03_Odd_Even","Connector_Generic:Conn_02x03_Odd_Even","Connector_IDC:IDC-Header_2x03_P2.54mm_Vertical","~","" +"18","1","J3","Conn_02x05_Odd_Even","Connector_Generic:Conn_02x05_Odd_Even","Connector_PinHeader_1.27mm:PinHeader_2x05_P1.27mm_Horizontal","~","" +"19","1","J4","TE 1-84982-0","Connector_Generic:Conn_01x10","INSA:TE 1-84982-0","~","" +"20","1","L1","10µH","Device:L","Inductor_SMD:L_Bourns_SRP7028A_7.3x6.6mm","~","" +"21","1","L2","5,6µH","Device:L","Inductor_SMD:L_1812_4532Metric","~","" +"22","2","M1, M2","Motor","Insa:Motor","INSA:Motor Pololu HPCB with encoder","","" +"23","1","P1","USB_C_Plug_GCT_USB4125","Insa:USB_C_Plug_GCT_USB4125","INSA:USB_C_Receptacle_GCT_USB4125","https://www.usb.org/sites/default/files/documents/usb_type-c.zip","" +"24","2","Q1, Q2","PMN52XP","Insa:PMN52XP","Package_SO:TSOP-6_1.65x3.05mm_P0.95mm","~","" +"25","8","R1, R2, R4, R20, R24, R27, R28, R29","100K","Device:R","Resistor_SMD:R_0805_2012Metric","~","" +"26","5","R3, R5, R7, R17, R18","1K","Device:R","Resistor_SMD:R_0805_2012Metric","~","" +"27","2","R6, R26","10K","Device:R","Resistor_SMD:R_0805_2012Metric","~","" +"28","1","R8","47K","Device:R","Resistor_SMD:R_0805_2012Metric","~","" +"29","1","R9","470","Device:R","Resistor_SMD:R_0805_2012Metric","~","" +"30","1","R10","40.2K","Device:R","Resistor_SMD:R_0805_2012Metric","~","" +"31","1","R11","13.3K","Device:R","Resistor_SMD:R_0805_2012Metric","~","" +"32","2","R12, R14","15K","Device:R","Resistor_SMD:R_0805_2012Metric","~","" +"33","1","R13","300","Device:R","Resistor_SMD:R_0805_2012Metric","~","" +"34","1","R19","150K","Device:R","Resistor_SMD:R_0805_2012Metric","~","" +"35","1","R25","10R","Device:R","Resistor_SMD:R_0805_2012Metric","~","" +"36","1","SW1","SW_Push","Switch:SW_Push","Button_Switch_SMD:Panasonic_EVQPUJ_EVQPUA","~","" +"37","1","U1","XBEE-3","Insa:XBEE-3","INSA:XBEE-3-TH","","" +"38","1","U2","STM32F071CBTx","MCU_ST_STM32F0:STM32F071CBTx","Package_QFP:LQFP-48_7x7mm_P0.5mm","http://www.st.com/st-web-ui/static/active/en/resource/technical/document/datasheet/DM00098745.pdf","" +"39","1","U3","LTC2954-2","Insa:LTC2954-2","Package_TO_SOT_SMD:SOT-23-8","","" +"40","1","U4","L6924U","Insa:L6924U","INSA:L6924UTR","","" +"41","1","U5","LM2731XMF","Regulator_Switching:LM2731XMF","Package_TO_SOT_SMD:SOT-23-5","http://www.ti.com/lit/ds/symlink/lm2731.pdf","" +"42","1","U6","AP2206","Regulator_Linear:TC1186","Package_TO_SOT_SMD:SOT-23-5","http://ww1.microchip.com/downloads/en/DeviceDoc/21350E.pdf","" +"43","1","U7","A3909","Insa:A3909","Package_SO:SSOP-10_3.9x4.9mm_P1.00mm","","" diff --git a/hardware/pcb/Dumber-v3/dumber-v3/dumber-v3.kicad_prl b/hardware/pcb/Dumber-v3/dumber-v3/dumber-v3.kicad_prl index 4d40239..a2132ae 100644 --- a/hardware/pcb/Dumber-v3/dumber-v3/dumber-v3.kicad_prl +++ b/hardware/pcb/Dumber-v3/dumber-v3/dumber-v3.kicad_prl @@ -1,12 +1,14 @@ { "board": { - "active_layer": 0, + "active_layer": 31, "active_layer_preset": "", "auto_track_width": true, + "hidden_netclasses": [], "hidden_nets": [], "high_contrast_mode": 0, "net_color_mode": 1, "opacity": { + "images": 0.6, "pads": 1.0, "tracks": 1.0, "vias": 1.0, @@ -62,7 +64,7 @@ 35, 36 ], - "visible_layers": "ff8fdff_80000001", + "visible_layers": "ff8ddff_80000000", "zone_display_mode": 0 }, "meta": { diff --git a/hardware/pcb/Dumber-v3/dumber-v3/dumber-v3.kicad_pro b/hardware/pcb/Dumber-v3/dumber-v3/dumber-v3.kicad_pro index 2c22c42..664a5da 100644 --- a/hardware/pcb/Dumber-v3/dumber-v3/dumber-v3.kicad_pro +++ b/hardware/pcb/Dumber-v3/dumber-v3/dumber-v3.kicad_pro @@ -1,5 +1,6 @@ { "board": { + "3dviewports": [], "design_settings": { "defaults": { "board_outline_line_width": 0.09999999999999999, @@ -74,8 +75,7 @@ "silk_over_copper|190300000|105210000|1992a7c6-c4b5-4e9a-ada0-bd5d4f8b1635|2922f406-8a01-4b6f-9ffd-33d2b73cda99", "silk_over_copper|190300000|113850000|1992a7c6-c4b5-4e9a-ada0-bd5d4f8b1635|de5d949f-b87e-4069-9f2b-fe65df0a3162", "silk_overlap|190300000|112500000|1992a7c6-c4b5-4e9a-ada0-bd5d4f8b1635|5162590d-5b34-444a-bf6f-4a7b61c57378", - "silk_overlap|190370000|112500000|5162590d-5b34-444a-bf6f-4a7b61c57378|1992a7c6-c4b5-4e9a-ada0-bd5d4f8b1635", - "track_dangling|158115000|109220000|d2605567-b159-4345-9b48-36b64b7f2d59|00000000-0000-0000-0000-000000000000" + "silk_overlap|190370000|112500000|5162590d-5b34-444a-bf6f-4a7b61c57378|1992a7c6-c4b5-4e9a-ada0-bd5d4f8b1635" ], "meta": { "version": 2 @@ -83,20 +83,26 @@ "rule_severities": { "annular_width": "error", "clearance": "error", + "connection_width": "warning", "copper_edge_clearance": "error", + "copper_sliver": "warning", "courtyards_overlap": "error", "diff_pair_gap_out_of_range": "error", "diff_pair_uncoupled_length_too_long": "error", "drill_out_of_range": "error", "duplicate_footprints": "warning", "extra_footprint": "warning", + "footprint": "error", "footprint_type_mismatch": "error", "hole_clearance": "error", "hole_near_hole": "error", "invalid_outline": "error", + "isolated_copper": "warning", "item_on_disabled_layer": "error", "items_not_allowed": "error", "length_out_of_range": "error", + "lib_footprint_issues": "warning", + "lib_footprint_mismatch": "warning", "malformed_courtyard": "ignore", "microvia_drill_out_of_range": "error", "missing_courtyard": "ignore", @@ -106,9 +112,14 @@ "padstack": "error", "pth_inside_courtyard": "ignore", "shorting_items": "error", + "silk_edge_clearance": "warning", "silk_over_copper": "warning", "silk_overlap": "warning", "skew_out_of_range": "error", + "solder_mask_bridge": "error", + "starved_thermal": "error", + "text_height": "warning", + "text_thickness": "warning", "through_hole_pad_without_hole": "error", "too_many_vias": "error", "track_dangling": "warning", @@ -117,7 +128,6 @@ "unconnected_items": "error", "unresolved_variable": "error", "via_dangling": "warning", - "zone_has_empty_net": "error", "zones_intersect": "error" }, "rules": { @@ -125,20 +135,65 @@ "allow_microvias": false, "max_error": 0.005, "min_clearance": 0.15, + "min_connection": 0.0, "min_copper_edge_clearance": 0.0, "min_hole_clearance": 0.19999999999999998, "min_hole_to_hole": 0.19999999999999998, "min_microvia_diameter": 0.19999999999999998, "min_microvia_drill": 0.09999999999999999, + "min_resolved_spokes": 2, "min_silk_clearance": 0.0, + "min_text_height": 0.7999999999999999, + "min_text_thickness": 0.08, "min_through_hole_diameter": 0.3, "min_track_width": 0.19999999999999998, "min_via_annular_width": 0.049999999999999996, "min_via_diameter": 0.39999999999999997, "solder_mask_clearance": 0.0, "solder_mask_min_width": 0.0, + "solder_mask_to_copper_clearance": 0.0, "use_height_for_length_calcs": true }, + "teardrop_options": [ + { + "td_allow_use_two_tracks": true, + "td_curve_segcount": 5, + "td_on_pad_in_zone": false, + "td_onpadsmd": true, + "td_onroundshapesonly": false, + "td_ontrackend": false, + "td_onviapad": true + } + ], + "teardrop_parameters": [ + { + "td_curve_segcount": 0, + "td_height_ratio": 1.0, + "td_length_ratio": 0.5, + "td_maxheight": 2.0, + "td_maxlen": 1.0, + "td_target_name": "td_round_shape", + "td_width_to_size_filter_ratio": 0.9 + }, + { + "td_curve_segcount": 0, + "td_height_ratio": 1.0, + "td_length_ratio": 0.5, + "td_maxheight": 2.0, + "td_maxlen": 1.0, + "td_target_name": "td_rect_shape", + "td_width_to_size_filter_ratio": 0.9 + }, + { + "td_curve_segcount": 0, + "td_height_ratio": 1.0, + "td_length_ratio": 0.5, + "td_maxheight": 2.0, + "td_maxlen": 1.0, + "td_target_name": "td_track_end", + "td_width_to_size_filter_ratio": 0.9 + } + ], "track_widths": [ 0.0, 0.2, @@ -187,7 +242,8 @@ "zones_allow_external_fillets": false, "zones_use_no_outline": true }, - "layer_presets": [] + "layer_presets": [], + "viewports": [] }, "boards": [], "cvpcb": { @@ -371,18 +427,23 @@ "rule_severities": { "bus_definition_conflict": "error", "bus_entry_needed": "error", - "bus_label_syntax": "error", "bus_to_bus_conflict": "error", "bus_to_net_conflict": "error", + "conflicting_netclasses": "error", "different_unit_footprint": "error", "different_unit_net": "error", "duplicate_reference": "error", "duplicate_sheet_names": "error", + "endpoint_off_grid": "warning", "extra_units": "error", "global_label_dangling": "warning", "hier_label_mismatch": "error", "label_dangling": "error", "lib_symbol_issues": "warning", + "missing_bidi_pin": "warning", + "missing_input_pin": "warning", + "missing_power_pin": "error", + "missing_unit": "warning", "multiple_net_names": "warning", "net_not_bus_member": "warning", "no_connect_connected": "warning", @@ -392,6 +453,7 @@ "pin_to_pin": "warning", "power_pin_not_driven": "error", "similar_labels": "warning", + "simulation_model_issue": "ignore", "unannotated": "error", "unit_value_mismatch": "error", "unresolved_variable": "error", @@ -409,7 +471,7 @@ "net_settings": { "classes": [ { - "bus_width": 12.0, + "bus_width": 12, "clearance": 0.15, "diff_pair_gap": 0.25, "diff_pair_via_gap": 0.25, @@ -423,13 +485,15 @@ "track_width": 0.2, "via_diameter": 0.8, "via_drill": 0.3, - "wire_width": 6.0 + "wire_width": 6 } ], "meta": { - "version": 2 + "version": 3 }, - "net_colors": null + "net_colors": null, + "netclass_assignments": null, + "netclass_patterns": [] }, "pcbnew": { "last_paths": { @@ -445,6 +509,8 @@ "schematic": { "annotate_start_num": 0, "drawing": { + "dashed_lines_dash_length_ratio": 12.0, + "dashed_lines_gap_length_ratio": 3.0, "default_line_thickness": 6.0, "default_text_size": 50.0, "field_names": [], @@ -476,7 +542,11 @@ "page_layout_descr_file": "", "plot_directory": "./", "spice_adjust_passive_values": false, + "spice_current_sheet_as_root": false, "spice_external_command": "spice \"%I\"", + "spice_model_current_sheet_as_root": true, + "spice_save_all_currents": false, + "spice_save_all_voltages": false, "subpart_first_id": 65, "subpart_id_separator": 0 }, diff --git a/hardware/pcb/Dumber-v3/dumber-v3/dumber-v3.xml b/hardware/pcb/Dumber-v3/dumber-v3/dumber-v3.xml new file mode 100644 index 0000000..a09eb73 --- /dev/null +++ b/hardware/pcb/Dumber-v3/dumber-v3/dumber-v3.xml @@ -0,0 +1,1718 @@ + + + + /home/dimercur/Travail/git/dumber/hardware/pcb/Dumber-v3/dumber-v3/dumber-v3.kicad_sch + lun. 04 sept. 2023 10:56:20 + Eeschema 7.0.7 + + + + <company>INSA - GEI</company> + <rev>1.0</rev> + <date>2022-06-08</date> + <source>dumber-v3.kicad_sch</source> + <comment number="1" value=""/> + <comment number="2" value=""/> + <comment number="3" value=""/> + <comment number="4" value=""/> + <comment number="5" value=""/> + <comment number="6" value=""/> + <comment number="7" value=""/> + <comment number="8" value=""/> + <comment number="9" value=""/> + </title_block> + </sheet> + <sheet number="2" name="/Power_Charge/" tstamps="/3615d78e-1dd3-4b20-9017-3539b8f88e06/"> + <title_block> + <title>Power & Charge + INSA - GEI + 2.1 + 2023-04-14 + power_charge.kicad_sch + + + + + + + + + + + + + + CPU + Com + Motors + INSA - GEI + 2.1 + 2023-03-29 + cpu.kicad_sch + + + + + + + + + + + + + + + Li-ION + INSA:Battery-14500 + + + + + + + 053dd8a9-6683-412e-b95b-646ea38b2cad + + + 10nF + Capacitor_SMD:C_0805_2012Metric + + + + + + + bd71a09f-c787-4676-9eaf-0b8a418617b8 + + + 68nF + Capacitor_SMD:C_0805_2012Metric + + + + + + + ff92073e-27c8-41ec-9759-376fd130aeda + + + 100µF + Capacitor_SMD:C_1210_3225Metric + + + + + + + 134fab3f-3d52-45ee-9c4d-4b9cd2356757 + + + 10nF + Capacitor_SMD:C_0805_2012Metric + + + + + + + 6a3d59a8-c0ed-4965-938e-bb8a6da91426 + + + 2.2µF + Capacitor_SMD:C_0805_2012Metric + + + + + + + 290b23d2-ab07-4d64-ad75-994bc73cc28d + + + 10µF + Capacitor_SMD:C_0805_2012Metric + + + + + + + b05e8c1b-5e98-418d-98a2-eb692cc0123e + + + 1µF + Capacitor_SMD:C_0805_2012Metric + + + + + + + 48167014-76fa-4d8e-bc63-24910f31eb11 + + + 650pF + Capacitor_SMD:C_0805_2012Metric + + + + + + + d7ec8307-042b-4921-9b77-d9ed100664d8 + + + 100pF + Capacitor_SMD:C_0805_2012Metric + + + + + + + 16366f03-a170-4809-ab0e-52a609d8b01f + + + 10µF + Capacitor_SMD:C_1210_3225Metric + + + + + + + a63b8def-5f1b-4d9d-bb74-90ccd6d05047 + + + 10µF + Capacitor_SMD:C_0805_2012Metric + + + + + + + 707c32d4-4845-4691-92d6-ca54beed384c + + + 1nF + Capacitor_SMD:C_0805_2012Metric + + + + + + + 6278b169-e9ba-49e9-9fd2-15de3e39aefb + + + PMEG2020CPA + INSA:Nexperia_SOT-1061 + + + + + + + d735c11c-af51-402c-bf6b-5022004af723 + + + FM5818-W + Diode_SMD:D_SMA + + + + + + + eccae0b8-7a04-4154-a5b0-d14898f4c17c + + + MountingHole + MountingHole:MountingHole_3.2mm_M3_ISO14580 + + + + + + + 70931bb2-f30a-426f-8190-d5c89b5e8222 + + + MountingHole + MountingHole:MountingHole_3.2mm_M3_ISO14580 + + + + + + + 318ca598-5b82-4017-94b2-876608dcab97 + + + MountingHole + MountingHole:MountingHole_3.2mm_M3_ISO14580 + + + + + + + fc812e6a-40f4-4cb6-9945-123fe42fd4ff + + + 10µH + Inductor_SMD:L_Bourns_SRP7028A_7.3x6.6mm + + + + + + + cb35137a-a8ed-4480-a7e1-1f175bdf4bd3 + + + USB_C_Plug_GCT_USB4125 + INSA:USB_C_Receptacle_GCT_USB4125 + https://www.usb.org/sites/default/files/documents/usb_type-c.zip + + + + + + + 4dc777e8-5202-4423-be17-f3ae17d6cde0 + + + PMN52XP + Package_SO:TSOP-6_1.65x3.05mm_P0.95mm + + + + + + + 9d11ce39-1eea-4ab9-afff-da40475d2a11 + + + 100K + Resistor_SMD:R_0805_2012Metric + + + + + + + c4af5280-8eac-4b95-8403-1a92f1254c42 + + + 100K + Resistor_SMD:R_0805_2012Metric + + + + + + + ed4d428a-cc2a-4f53-afda-674212f35d1e + + + 1K + Resistor_SMD:R_0805_2012Metric + + + + + + + 468f85cf-b8ed-4484-8706-38e3909e7f05 + + + 100K + Resistor_SMD:R_0805_2012Metric + + + + + + + 97f52b40-ab06-42cd-8299-1f1d164626ad + + + 1K + Resistor_SMD:R_0805_2012Metric + + + + + + + bdd1b1f3-79e7-447d-9aa5-d02adb05078a + + + 10K + Resistor_SMD:R_0805_2012Metric + + + + + + + e3f40ac5-c9c1-4431-a244-41e8c460c1d2 + + + 1K + Resistor_SMD:R_0805_2012Metric + + + + + + + c977f81e-4ab7-4d26-bbf3-098b09afe477 + + + 47K + Resistor_SMD:R_0805_2012Metric + + + + + + + 58ee17a8-90a8-405f-9a19-8126994f76ff + + + 470 + Resistor_SMD:R_0805_2012Metric + + + + + + + 0ea2454f-b423-4f55-8c11-36db50920ffb + + + 40.2K + Resistor_SMD:R_0805_2012Metric + + + + + + + e257cddb-a9e9-4642-b7b3-1ba1238ca42a + + + 13.3K + Resistor_SMD:R_0805_2012Metric + + + + + + + f13b9b51-766a-4b76-a09c-958c9da8f460 + + + 15K + Resistor_SMD:R_0805_2012Metric + + + + + + + da5fc659-2f73-4499-97f7-301d8bfb0ffa + + + 300 + Resistor_SMD:R_0805_2012Metric + + + + + + + 3db638a4-555f-4907-9209-4f7decb8a38c + + + 15K + Resistor_SMD:R_0805_2012Metric + + + + + + + df2f3a3c-018d-44e4-a157-467cac57137f + + + 1K + Resistor_SMD:R_0805_2012Metric + + + + + + + 6d0a8559-6806-445a-9150-dfd0496b6eb9 + + + 1K + Resistor_SMD:R_0805_2012Metric + + + + + + + ba1007a3-0af2-4834-92d5-3072900399bf + + + 150K + Resistor_SMD:R_0805_2012Metric + + + + + + + e42db9c1-d0b1-48cf-863c-06bec79e4892 + + + 100K + Resistor_SMD:R_0805_2012Metric + + + + + + + afedd976-fee3-498a-a95d-a679b70be92a + + + SW_Push + Button_Switch_SMD:Panasonic_EVQPUJ_EVQPUA + + + + + + + a2307e07-4a0e-45a0-860c-02d4c012955d + + + LTC2954-2 + Package_TO_SOT_SMD:SOT-23-8 + + + + + 1c6e7514-e426-4cb3-922e-1293285c7252 + + + L6924U + INSA:L6924UTR + + + + + b11c64a9-01d5-4411-a940-0a1faea7840e + + + LM2731XMF + Package_TO_SOT_SMD:SOT-23-5 + http://www.ti.com/lit/ds/symlink/lm2731.pdf + + + + + + + 0bc43163-613d-49e2-b443-50b6bf7d3320 + + + AP2206 + Package_TO_SOT_SMD:SOT-23-5 + http://ww1.microchip.com/downloads/en/DeviceDoc/21350E.pdf + + + + + + + fa604296-bc37-4ba5-96fe-4590ffd6650e + + + 1µF + Capacitor_SMD:C_0805_2012Metric + + + + + + + 3b6b3612-3075-4103-a4ca-2af50c36e62f + + + 1µF + Capacitor_SMD:C_0805_2012Metric + + + + + + + 4ea93de4-5e17-4d11-b46b-d6ff189af8c9 + + + 470nF + Capacitor_SMD:C_0805_2012Metric + + + + + + + 15085dfc-47f4-4f8e-8b33-010f139cbd2e + + + 470nF + Capacitor_SMD:C_0805_2012Metric + + + + + + + 3f85c904-e97d-4be1-a718-e5c6add66c0a + + + 100nF + Capacitor_SMD:C_0805_2012Metric + + + + + + + 5c6cbf4a-879f-44a0-95ad-6088994ddad8 + + + 100nF + Capacitor_SMD:C_0805_2012Metric + + + + + + + 3d7147e1-c45f-4241-a086-49e65ede1cfc + + + 100nF + Capacitor_SMD:C_0805_2012Metric + + + + + + + dc12807b-c3e2-45ed-bc8b-70aa2a59fa1d + + + 100nF + Capacitor_SMD:C_0805_2012Metric + + + + + + + 98c4472a-5e03-44c4-9716-29e540c0c9a8 + + + 1µF + Capacitor_SMD:C_0805_2012Metric + + + + + + + d069a740-be16-4a07-a109-3d0a4d054b2c + + + Conn_02x03_Odd_Even + Connector_IDC:IDC-Header_2x03_P2.54mm_Vertical + + + + + + + ad90e2d3-97b9-46c2-8dd0-1f06ea84ef6b + + + Conn_02x03_Odd_Even + Connector_IDC:IDC-Header_2x03_P2.54mm_Vertical + + + + + + + c97ea1a1-2376-4cd0-8a00-d3a918354196 + + + Conn_02x05_Odd_Even + Connector_PinHeader_1.27mm:PinHeader_2x05_P1.27mm_Horizontal + + + + + + + eb3899c1-5b12-45e0-8c00-fdefc61483aa + + + TE 1-84982-0 + INSA:TE 1-84982-0 + + + + + + + d9436e2a-adfe-4a85-b564-02e5a41ce103 + + + 5,6µH + Inductor_SMD:L_1812_4532Metric + + + + + + + 1de66d59-5ad6-4cb3-bd79-a70bb7fb7c31 + + + Motor + INSA:Motor Pololu HPCB with encoder + + + + + b8ba459f-4564-488d-a7fd-fbd97b4a8b51 + + + Motor + INSA:Motor Pololu HPCB with encoder + + + + + f1bd1fe0-35c5-4640-a5a2-987c962cef4d + + + PMN52XP + Package_SO:TSOP-6_1.65x3.05mm_P0.95mm + + + + + + + bb39413a-ecc1-4c94-be5e-9137638cdb55 + + + 100K + Resistor_SMD:R_0805_2012Metric + + + + + + + b6914fe2-614d-400f-b838-b498fec4ecdb + + + 10R + Resistor_SMD:R_0805_2012Metric + + + + + + + ce48cef0-09dc-48a7-a258-245d78655b72 + + + 10K + Resistor_SMD:R_0805_2012Metric + + + + + + + 847724be-a104-4b2b-97ba-095b66aec5e9 + + + 100K + Resistor_SMD:R_0805_2012Metric + + + + + + + e6a1085f-5a65-4db9-bac7-9009c0f501d3 + + + 100K + Resistor_SMD:R_0805_2012Metric + + + + + + + c7cbf0d2-3176-4cd7-ba2e-24ec0fda6d15 + + + 100K + Resistor_SMD:R_0805_2012Metric + + + + + + + 55c285af-34fa-4d9f-bd8d-eb33fdce8091 + + + XBEE-3 + INSA:XBEE-3-TH + + + + + a2266a25-f3f8-4b9b-b976-3534cc857ce9 + + + STM32F071CBTx + Package_QFP:LQFP-48_7x7mm_P0.5mm + http://www.st.com/st-web-ui/static/active/en/resource/technical/document/datasheet/DM00098745.pdf + + + + + + + aaa8473f-a3e4-47b7-a194-0a55d2850cad + + + A3909 + Package_SO:SSOP-10_3.9x4.9mm_P1.00mm + + + + + + c97c9187-033d-4fd2-9ea6-1190524d9af0 + + + + + Generic connector, single row, 01x10, script generated (kicad-library-utils/schlib/autogen/connector/) + ~ + + Connector*:*_1x??_* + + + J + Conn_01x10 + ~ + + + + + + + + + + + + + + + + Generic connector, double row, 02x03, odd/even pin numbering scheme (row 1 odd numbers, row 2 even numbers), script generated (kicad-library-utils/schlib/autogen/connector/) + ~ + + Connector*:*_2x??_* + + + J + Conn_02x03_Odd_Even + ~ + + + + + + + + + + + + Generic connector, double row, 02x05, odd/even pin numbering scheme (row 1 odd numbers, row 2 even numbers), script generated (kicad-library-utils/schlib/autogen/connector/) + ~ + + Connector*:*_2x??_* + + + J + Conn_02x05_Odd_Even + ~ + + + + + + + + + + + + + + + + Single-cell battery + ~ + + BT + Battery_Cell + ~ + + + + + + + + Unpolarized capacitor + ~ + + C_* + + + C + C + ~ + + + + + + + + Dual diode, common anode on pin 1 + ~ + + D + D_Dual_CommonCathode_AAK_Parallel + ~ + + + + + + + + + Schottky diode + ~ + + TO-???* + *_Diode_* + *SingleDiode* + D_* + + + D + D_Schottky + ~ + + + + + + + + Inductor + ~ + + Choke_* + *Coil* + Inductor_* + L_* + + + L + L + ~ + + + + + + + + Resistor + ~ + + R_* + + + R + R + ~ + + + + + + + + Dual Full Bridge Motor Driver + + U + A3909 + Package_SO:SSOP-10_3.9x4.9mm_P1.00mm + + + + + + + + + + + + + + + + + U + L6924U + Package_DFN_QFN:VQFN-16-1EP_3x3mm_P0.5mm_EP1.6x1.6mm_ThermalVias + + + + + + + + + + + + + + + + + + + + + + + + U + LTC2954-2 + Package_TO_SOT_SMD:SOT-23-8 + + + + + + + + + + + + + + + M + Motor + + + + P-MOSFET transistor, gate/drain/source, drain connected to mounting plane + ~ + + Q + PMN52XP + Package_SO:TSOP-6_1.65x3.05mm_P0.95mm + ~ + + + + + + + + + + + + USB 2.0-only Type-C Plug connector + https://www.usb.org/sites/default/files/documents/usb_type-c.zip + + USB*C*Plug* + + + P + USB_C_Plug_GCT_USB4125 + INSA:USB_C_Receptacle_GCT_USB4125 + https://www.usb.org/sites/default/files/documents/usb_type-c.zip + + + + + + + + + + + + + + U + XBEE-3 + INSA:XBEE-3-TH + + + + + + + + + + + + + + + + + + + + + + + + ARM Cortex-M0 MCU, 128KB flash, 16KB RAM, 48MHz, 2-3.6V, 37 GPIO, LQFP-48 + http://www.st.com/st-web-ui/static/active/en/resource/technical/document/datasheet/DM00098745.pdf + + LQFP*7x7mm*P0.5mm* + + + U + STM32F071CBTx + Package_QFP:LQFP-48_7x7mm_P0.5mm + http://www.st.com/st-web-ui/static/active/en/resource/technical/document/datasheet/DM00098745.pdf + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Mounting Hole without connection + ~ + + MountingHole* + + + H + MountingHole + ~ + + + + 150mA Low Dropout Regulator with ERROR output in 5-Pin SOT-23 package + http://ww1.microchip.com/downloads/en/DeviceDoc/21350E.pdf + + SOT?23* + + + U + TC1186 + Package_TO_SOT_SMD:SOT-23-5 + http://ww1.microchip.com/downloads/en/DeviceDoc/21350E.pdf + + + + + + + + + + + LM27313, 1.8A, 22Vout Boost Voltage Regulator, 1.6MHz Frequency, SOT-23-5 + http://www.ti.com/lit/ds/symlink/lm2731.pdf + + SOT?23* + + + U + LM2731XMF + Package_TO_SOT_SMD:SOT-23-5 + http://www.ti.com/lit/ds/symlink/lm2731.pdf + + + + + + + + + + + Push button switch, generic, two pins + ~ + + SW + SW_Push + ~ + + + + + + + + + + /app/extensions/Library/symbols//Connector_Generic.kicad_sym + + + /app/extensions/Library/symbols//Device.kicad_sym + + + /app/extensions/Library/symbols//MCU_ST_STM32F0.kicad_sym + + + /app/extensions/Library/symbols//Mechanical.kicad_sym + + + /app/extensions/Library/symbols//Regulator_Linear.kicad_sym + + + /app/extensions/Library/symbols//Regulator_Switching.kicad_sym + + + /app/extensions/Library/symbols//Switch.kicad_sym + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/hardware/pcb/Dumber-v3/ecran/ecran/ecran.kicad_pcb b/hardware/pcb/Dumber-v3/ecran/ecran/ecran.kicad_pcb index 7c544a6..64c29e5 100644 --- a/hardware/pcb/Dumber-v3/ecran/ecran/ecran.kicad_pcb +++ b/hardware/pcb/Dumber-v3/ecran/ecran/ecran.kicad_pcb @@ -7,8 +7,8 @@ (paper "A4") (title_block (title "Ecran pour Dumber") - (date "2023-02-17") - (rev "V1.0") + (date "2023-04-18") + (rev "V1.1") (company "INSA GEI") ) @@ -106,14 +106,14 @@ (net 9 "Net-(DS1-Pad11)") (net 10 "unconnected-(DS1-Pad7)") (net 11 "unconnected-(J1-Pad1)") - (net 12 "Net-(R1-Pad1)") - (net 13 "Net-(R2-Pad1)") - (net 14 "Net-(R3-Pad1)") - (net 15 "Net-(R4-Pad1)") - (net 16 "Net-(R5-Pad1)") - (net 17 "Net-(R6-Pad1)") - (net 18 "Net-(R7-Pad1)") - (net 19 "Net-(R8-Pad1)") + (net 12 "Net-(J1-Pad2)") + (net 13 "Net-(J1-Pad3)") + (net 14 "Net-(J1-Pad4)") + (net 15 "Net-(J1-Pad5)") + (net 16 "Net-(J1-Pad6)") + (net 17 "Net-(J1-Pad7)") + (net 18 "Net-(J1-Pad8)") + (net 19 "Net-(J1-Pad9)") (footprint "Resistor_SMD:R_0805_2012Metric" (layer "F.Cu") (tedit 5F68FEEE) (tstamp 026cd71f-0cfc-488d-aa05-ed48789f7cd9) @@ -124,7 +124,7 @@ (property "Sheetname" "") (path "/bdcf52eb-ff1a-4908-97e0-29ca08c521c8") (attr smd) - (fp_text reference "R5" (at -3.175 0 90) (layer "F.SilkS") + (fp_text reference "R5" (at -3.175 1.27 90) (layer "F.SilkS") (effects (font (size 1 1) (thickness 0.15))) (tstamp b595dc3a-25ca-49a2-bccf-641437621b9e) ) @@ -147,7 +147,7 @@ (fp_line (start 1 0.625) (end -1 0.625) (layer "F.Fab") (width 0.1) (tstamp 79fdcfcf-b8ad-41f7-8fe3-dba2e51d2851)) (fp_line (start 1 -0.625) (end 1 0.625) (layer "F.Fab") (width 0.1) (tstamp adea0a4c-32f2-4d84-8052-542dca55b48d)) (pad "1" smd roundrect (at -0.9125 0 90) (size 1.025 1.4) (layers "F.Cu" "F.Paste" "F.Mask") (roundrect_rratio 0.243902439) - (net 16 "Net-(R5-Pad1)") (pintype "passive") (tstamp c060fd89-0678-4364-b717-004d4e5bf1a7)) + (net 16 "Net-(J1-Pad6)") (pintype "passive") (tstamp c060fd89-0678-4364-b717-004d4e5bf1a7)) (pad "2" smd roundrect (at 0.9125 0 90) (size 1.025 1.4) (layers "F.Cu" "F.Paste" "F.Mask") (roundrect_rratio 0.243902439) (net 8 "Net-(DS1-Pad10)") (pintype "passive") (tstamp 28444a43-2ea8-4f9d-af8a-0944feea1134)) (model "${KICAD6_3DMODEL_DIR}/Resistor_SMD.3dshapes/R_0805_2012Metric.wrl" @@ -189,7 +189,7 @@ (fp_line (start -1 0.625) (end -1 -0.625) (layer "F.Fab") (width 0.1) (tstamp 7ff1b6b5-7983-4b27-8696-e5fee43e1998)) (fp_line (start -1 -0.625) (end 1 -0.625) (layer "F.Fab") (width 0.1) (tstamp a73b745b-1870-4424-a69a-c20b941aa912)) (pad "1" smd roundrect (at -0.9125 0 90) (size 1.025 1.4) (layers "F.Cu" "F.Paste" "F.Mask") (roundrect_rratio 0.243902439) - (net 15 "Net-(R4-Pad1)") (pintype "passive") (tstamp 9e38765f-a5a2-4ff1-8f99-da460f524a29)) + (net 15 "Net-(J1-Pad5)") (pintype "passive") (tstamp 9e38765f-a5a2-4ff1-8f99-da460f524a29)) (pad "2" smd roundrect (at 0.9125 0 90) (size 1.025 1.4) (layers "F.Cu" "F.Paste" "F.Mask") (roundrect_rratio 0.243902439) (net 9 "Net-(DS1-Pad11)") (pintype "passive") (tstamp 2635a5dd-deb9-4652-a861-da9284acbb6c)) (model "${KICAD6_3DMODEL_DIR}/Resistor_SMD.3dshapes/R_0805_2012Metric.wrl" @@ -257,7 +257,7 @@ (fp_line (start -1 0.625) (end -1 -0.625) (layer "F.Fab") (width 0.1) (tstamp 46751f89-53a5-4bcc-805a-0c250c7ea33e)) (fp_line (start -1 -0.625) (end 1 -0.625) (layer "F.Fab") (width 0.1) (tstamp aa93c565-06a2-4d4a-9a6a-b4c840d27b59)) (pad "1" smd roundrect (at -0.9125 0) (size 1.025 1.4) (layers "F.Cu" "F.Paste" "F.Mask") (roundrect_rratio 0.243902439) - (net 18 "Net-(R7-Pad1)") (pintype "passive") (tstamp e622aa68-fa00-4d76-bf4c-65594358a507)) + (net 18 "Net-(J1-Pad8)") (pintype "passive") (tstamp e622aa68-fa00-4d76-bf4c-65594358a507)) (pad "2" smd roundrect (at 0.9125 0) (size 1.025 1.4) (layers "F.Cu" "F.Paste" "F.Mask") (roundrect_rratio 0.243902439) (net 6 "Net-(DS1-Pad6)") (pintype "passive") (tstamp 4145edc9-d6b1-45eb-a02e-d9875f389d81)) (model "${KICAD6_3DMODEL_DIR}/Resistor_SMD.3dshapes/R_0805_2012Metric.wrl" @@ -325,7 +325,7 @@ (fp_line (start 1 -0.625) (end 1 0.625) (layer "F.Fab") (width 0.1) (tstamp 870d620a-2c41-4c1f-9307-d64ef80cbf8f)) (fp_line (start -1 0.625) (end -1 -0.625) (layer "F.Fab") (width 0.1) (tstamp fae58b11-f691-4237-ad7a-b187372a8d7c)) (pad "1" smd roundrect (at -0.9125 0) (size 1.025 1.4) (layers "F.Cu" "F.Paste" "F.Mask") (roundrect_rratio 0.243902439) - (net 13 "Net-(R2-Pad1)") (pintype "passive") (tstamp f748a169-f3ee-49c2-9ff2-83f12cbd3de6)) + (net 13 "Net-(J1-Pad3)") (pintype "passive") (tstamp f748a169-f3ee-49c2-9ff2-83f12cbd3de6)) (pad "2" smd roundrect (at 0.9125 0) (size 1.025 1.4) (layers "F.Cu" "F.Paste" "F.Mask") (roundrect_rratio 0.243902439) (net 1 "Net-(DS1-Pad1)") (pintype "passive") (tstamp 9ddc7c64-7533-4747-9d1d-d53b805b046e)) (model "${KICAD6_3DMODEL_DIR}/Resistor_SMD.3dshapes/R_0805_2012Metric.wrl" @@ -367,7 +367,7 @@ (fp_line (start -1 0.625) (end -1 -0.625) (layer "F.Fab") (width 0.1) (tstamp a82b3432-4152-4915-9ac3-3715ce9966d8)) (fp_line (start -1 -0.625) (end 1 -0.625) (layer "F.Fab") (width 0.1) (tstamp a895b52c-7e94-4f30-b52b-186a5d2269a3)) (pad "1" smd roundrect (at -0.9125 0) (size 1.025 1.4) (layers "F.Cu" "F.Paste" "F.Mask") (roundrect_rratio 0.243902439) - (net 19 "Net-(R8-Pad1)") (pintype "passive") (tstamp 7e124048-f0da-43e6-a7f7-cc3acfcf8138)) + (net 19 "Net-(J1-Pad9)") (pintype "passive") (tstamp 7e124048-f0da-43e6-a7f7-cc3acfcf8138)) (pad "2" smd roundrect (at 0.9125 0) (size 1.025 1.4) (layers "F.Cu" "F.Paste" "F.Mask") (roundrect_rratio 0.243902439) (net 5 "Net-(DS1-Pad5)") (pintype "passive") (tstamp 6468a754-d492-483b-8a4c-d6f4ff3ed46d)) (model "${KICAD6_3DMODEL_DIR}/Resistor_SMD.3dshapes/R_0805_2012Metric.wrl" @@ -386,7 +386,7 @@ (property "Sheetname" "") (path "/7f464942-3c10-45a7-9321-d36507eee8aa") (attr smd) - (fp_text reference "R6" (at -3.175 0 90) (layer "F.SilkS") + (fp_text reference "R6" (at -3.175 1.905 90) (layer "F.SilkS") (effects (font (size 1 1) (thickness 0.15))) (tstamp 0472fc91-6f37-4b09-ba8d-aa53572a8d53) ) @@ -409,7 +409,7 @@ (fp_line (start 1 0.625) (end -1 0.625) (layer "F.Fab") (width 0.1) (tstamp c3a72c32-217c-45fa-bcde-8ea3ba9a9197)) (fp_line (start 1 -0.625) (end 1 0.625) (layer "F.Fab") (width 0.1) (tstamp ea1f4897-04cb-40e9-a553-073272bbad2a)) (pad "1" smd roundrect (at -0.9125 0 90) (size 1.025 1.4) (layers "F.Cu" "F.Paste" "F.Mask") (roundrect_rratio 0.243902439) - (net 17 "Net-(R6-Pad1)") (pintype "passive") (tstamp f49b6221-5b47-4b80-83d2-841a2def498c)) + (net 17 "Net-(J1-Pad7)") (pintype "passive") (tstamp f49b6221-5b47-4b80-83d2-841a2def498c)) (pad "2" smd roundrect (at 0.9125 0 90) (size 1.025 1.4) (layers "F.Cu" "F.Paste" "F.Mask") (roundrect_rratio 0.243902439) (net 7 "Net-(DS1-Pad8)") (pintype "passive") (tstamp 84e6c686-c028-4603-bd5e-46dd1870f815)) (model "${KICAD6_3DMODEL_DIR}/Resistor_SMD.3dshapes/R_0805_2012Metric.wrl" @@ -451,7 +451,7 @@ (fp_line (start -1 0.625) (end -1 -0.625) (layer "F.Fab") (width 0.1) (tstamp eade6e92-55d7-4ed4-a0c8-bb6ddcacf564)) (fp_line (start 1 -0.625) (end 1 0.625) (layer "F.Fab") (width 0.1) (tstamp fce40fd7-b793-49f0-91d9-d17a4dc68f3f)) (pad "1" smd roundrect (at -0.9125 0) (size 1.025 1.4) (layers "F.Cu" "F.Paste" "F.Mask") (roundrect_rratio 0.243902439) - (net 14 "Net-(R3-Pad1)") (pintype "passive") (tstamp b8e47bd1-06ca-4864-aed5-4535e5a88c10)) + (net 14 "Net-(J1-Pad4)") (pintype "passive") (tstamp b8e47bd1-06ca-4864-aed5-4535e5a88c10)) (pad "2" smd roundrect (at 0.9125 0) (size 1.025 1.4) (layers "F.Cu" "F.Paste" "F.Mask") (roundrect_rratio 0.243902439) (net 4 "Net-(DS1-Pad3)") (pintype "passive") (tstamp 8250e891-08f2-4b20-bd64-e4eb1f07d6c5)) (model "${KICAD6_3DMODEL_DIR}/Resistor_SMD.3dshapes/R_0805_2012Metric.wrl" @@ -599,7 +599,7 @@ (fp_line (start 1 -0.625) (end 1 0.625) (layer "F.Fab") (width 0.1) (tstamp 5bbe7b24-637f-4080-93aa-bf77d7587705)) (fp_line (start 1 0.625) (end -1 0.625) (layer "F.Fab") (width 0.1) (tstamp d5ee33e5-1304-4788-ae0a-2f0f835a6196)) (pad "1" smd roundrect (at -0.9125 0) (size 1.025 1.4) (layers "F.Cu" "F.Paste" "F.Mask") (roundrect_rratio 0.243902439) - (net 12 "Net-(R1-Pad1)") (pintype "passive") (tstamp e6b3c353-cbbe-4ec9-9014-32f981f78d2e)) + (net 12 "Net-(J1-Pad2)") (pintype "passive") (tstamp e6b3c353-cbbe-4ec9-9014-32f981f78d2e)) (pad "2" smd roundrect (at 0.9125 0) (size 1.025 1.4) (layers "F.Cu" "F.Paste" "F.Mask") (roundrect_rratio 0.243902439) (net 2 "Net-(DS1-Pad2)") (pintype "passive") (tstamp bd619bd0-7293-4883-a8a7-b6a9788272ee)) (model "${KICAD6_3DMODEL_DIR}/Resistor_SMD.3dshapes/R_0805_2012Metric.wrl" @@ -635,21 +635,21 @@ (pad "1" smd rect locked (at -4.5 0.35 270) (size 0.6 1.7) (layers "B.Cu" "B.Paste" "B.Mask") (net 11 "unconnected-(J1-Pad1)") (pinfunction "Pin_1") (pintype "passive+no_connect") (tstamp 08820a79-b4e3-4020-a942-e36a5a6ac453)) (pad "2" smd rect locked (at -3.5 0.35 270) (size 0.6 1.7) (layers "B.Cu" "B.Paste" "B.Mask") - (net 12 "Net-(R1-Pad1)") (pinfunction "Pin_2") (pintype "passive") (tstamp 0b428485-46f9-4775-b80c-6397b2e0063f)) + (net 12 "Net-(J1-Pad2)") (pinfunction "Pin_2") (pintype "passive") (tstamp 0b428485-46f9-4775-b80c-6397b2e0063f)) (pad "3" smd rect locked (at -2.5 0.35 270) (size 0.6 1.7) (layers "B.Cu" "B.Paste" "B.Mask") - (net 13 "Net-(R2-Pad1)") (pinfunction "Pin_3") (pintype "passive") (tstamp d562a1e2-4bc3-474e-9da8-8d80c8a59814)) + (net 13 "Net-(J1-Pad3)") (pinfunction "Pin_3") (pintype "passive") (tstamp d562a1e2-4bc3-474e-9da8-8d80c8a59814)) (pad "4" smd rect locked (at -1.5 0.35 270) (size 0.6 1.7) (layers "B.Cu" "B.Paste" "B.Mask") - (net 14 "Net-(R3-Pad1)") (pinfunction "Pin_4") (pintype "passive") (tstamp 91e163ac-2f85-4027-8efb-e55a2d097e9a)) + (net 14 "Net-(J1-Pad4)") (pinfunction "Pin_4") (pintype "passive") (tstamp 91e163ac-2f85-4027-8efb-e55a2d097e9a)) (pad "5" smd rect locked (at -0.5 0.35 270) (size 0.6 1.7) (layers "B.Cu" "B.Paste" "B.Mask") - (net 15 "Net-(R4-Pad1)") (pinfunction "Pin_5") (pintype "passive") (tstamp 638d9b07-c71d-42da-8623-5711b322446b)) + (net 15 "Net-(J1-Pad5)") (pinfunction "Pin_5") (pintype "passive") (tstamp 638d9b07-c71d-42da-8623-5711b322446b)) (pad "6" smd rect locked (at 0.5 0.35 270) (size 0.6 1.7) (layers "B.Cu" "B.Paste" "B.Mask") - (net 16 "Net-(R5-Pad1)") (pinfunction "Pin_6") (pintype "passive") (tstamp 49cb1c3e-dccf-4884-ba9f-dbd5ec8f8a62)) + (net 16 "Net-(J1-Pad6)") (pinfunction "Pin_6") (pintype "passive") (tstamp 49cb1c3e-dccf-4884-ba9f-dbd5ec8f8a62)) (pad "7" smd rect locked (at 1.5 0.35 270) (size 0.6 1.7) (layers "B.Cu" "B.Paste" "B.Mask") - (net 17 "Net-(R6-Pad1)") (pinfunction "Pin_7") (pintype "passive") (tstamp 2d4dd5c4-92fb-4ee2-a71e-093c39051399)) + (net 17 "Net-(J1-Pad7)") (pinfunction "Pin_7") (pintype "passive") (tstamp 2d4dd5c4-92fb-4ee2-a71e-093c39051399)) (pad "8" smd rect locked (at 2.5 0.35 270) (size 0.6 1.7) (layers "B.Cu" "B.Paste" "B.Mask") - (net 18 "Net-(R7-Pad1)") (pinfunction "Pin_8") (pintype "passive") (tstamp 25b70e0a-cc06-438e-847f-c9aceed199ab)) + (net 18 "Net-(J1-Pad8)") (pinfunction "Pin_8") (pintype "passive") (tstamp 25b70e0a-cc06-438e-847f-c9aceed199ab)) (pad "9" smd rect locked (at 3.5 0.35 270) (size 0.6 1.7) (layers "B.Cu" "B.Paste" "B.Mask") - (net 19 "Net-(R8-Pad1)") (pinfunction "Pin_9") (pintype "passive") (tstamp 495f6d67-cdad-41f4-8c78-29069294d0a5)) + (net 19 "Net-(J1-Pad9)") (pinfunction "Pin_9") (pintype "passive") (tstamp 495f6d67-cdad-41f4-8c78-29069294d0a5)) (pad "10" smd rect locked (at 4.5 0.35 270) (size 0.6 1.7) (layers "B.Cu" "B.Paste" "B.Mask") (net 3 "GND") (pinfunction "Pin_10") (pintype "passive") (tstamp cfa0082d-03b8-40fb-8226-1a39e1f7511d)) (pad "11" smd rect locked (at 6.3 -4.9 270) (size 1.2 1.8) (layers "B.Cu" "B.Paste" "B.Mask") (tstamp 5a6ab7af-3d4d-465a-98f7-01589d633060)) @@ -665,7 +665,7 @@ (gr_line (start 127 96) (end 127 120) (layer "Edge.Cuts") (width 0.1) (tstamp 59c97e15-26a7-4231-8d66-1f6423f9197d)) (gr_line (start 95.885 120) (end 95.885 96) (layer "Edge.Cuts") (width 0.1) (tstamp 7a26ff8d-82ea-4fb2-8526-07d5499981e9)) (gr_line (start 95.885 96) (end 127 96) (layer "Edge.Cuts") (width 0.1) (tstamp bfac0be8-d941-4ec0-8418-7aca3d109cec)) - (gr_text "Ecran Dumber\nV1.0\n02/23 - INSA GEI" (at 116.205 107.95 270) (layer "B.SilkS") (tstamp 49826c65-2028-4080-b7e2-8b79952a37e7) + (gr_text "Ecran Dumber\nV1.1\n04/23 - INSA GEI" (at 116.205 107.95 270) (layer "B.SilkS") (tstamp 49826c65-2028-4080-b7e2-8b79952a37e7) (effects (font (size 1 1) (thickness 0.15)) (justify mirror)) ) (target plus (at 89 121) (size 5) (width 0.1) (layer "Edge.Cuts") (tstamp 2e4a87c2-d9cc-4ff7-8d17-8961ef959f6d)) @@ -688,6 +688,7 @@ (segment (start 111.76 109.855) (end 116.84 109.855) (width 0.35) (layer "B.Cu") (net 3) (tstamp 9ffa1660-c037-481a-baa5-70118d00a38f)) (segment (start 110.865 103.8425) (end 104.4175 110.29) (width 0.35) (layer "F.Cu") (net 4) (tstamp 39c80ce7-1925-49f9-b62d-4ece7f92acb6)) (segment (start 110.865 99.1) (end 110.865 103.8425) (width 0.35) (layer "F.Cu") (net 4) (tstamp 484742b7-53c3-4fe3-ba63-21cf1bcb98c0)) + (segment (start 104.4175 110.29) (end 104.4175 111.225) (width 0.35) (layer "F.Cu") (net 4) (tstamp 77043d29-80a4-4302-adc7-5ff8a027f8e0)) (segment (start 118.3875 103.505) (end 113.665 103.505) (width 0.35) (layer "F.Cu") (net 5) (tstamp 5a243972-a958-4f36-968d-c95f7ec17e86)) (segment (start 113.665 103.505) (end 113.405 103.245) (width 0.35) (layer "F.Cu") (net 5) (tstamp 5f00f099-c50a-495f-af3b-5b02490dced9)) (segment (start 113.405 103.245) (end 113.405 99.1) (width 0.35) (layer "F.Cu") (net 5) (tstamp 724c9308-b9c2-4e06-a799-9929e440d6d6)) @@ -1613,7 +1614,7 @@ (xy 99.357941 109.444946) (xy 99.353624 109.458555) (xy 99.297484 109.635532) - (xy 99.290731 109.695738) + (xy 99.292716 109.678043) (xy 99.278625 109.803668) (xy 99.27452 109.840262) (xy 99.291759 110.045553) @@ -2032,12 +2033,14 @@ (xy 117.398304 109.535291) (xy 117.445617 109.628149) (xy 117.564743 109.775257) + (xy 117.56979 109.779344) + (xy 117.659203 109.851749) (xy 117.711851 109.894383) (xy 117.71764 109.897332) (xy 117.717642 109.897334) (xy 117.777828 109.928) (xy 117.880512 109.98032) - (xy 117.943734 109.99726) + (xy 117.94498 109.997594) (xy 118.057863 110.027841) (xy 118.057869 110.027842) (xy 118.063355 110.029312) @@ -2065,7 +2068,7 @@ (xy 119.542642 109.897334) (xy 119.602828 109.928) (xy 119.705512 109.98032) - (xy 119.768734 109.99726) + (xy 119.76998 109.997594) (xy 119.882863 110.027841) (xy 119.882869 110.027842) (xy 119.888355 110.029312) @@ -2082,6 +2085,8 @@ (xy 121.042358 109.897334) (xy 121.04236 109.897332) (xy 121.048149 109.894383) + (xy 121.100798 109.851749) + (xy 121.19021 109.779344) (xy 121.195257 109.775257) (xy 121.314383 109.628149) (xy 121.361697 109.535291) diff --git a/hardware/pcb/Dumber-v3/ecran/ecran/ecran.kicad_prl b/hardware/pcb/Dumber-v3/ecran/ecran/ecran.kicad_prl index 7039ef5..c78aeb4 100644 --- a/hardware/pcb/Dumber-v3/ecran/ecran/ecran.kicad_prl +++ b/hardware/pcb/Dumber-v3/ecran/ecran/ecran.kicad_prl @@ -1,6 +1,6 @@ { "board": { - "active_layer": 0, + "active_layer": 37, "active_layer_preset": "", "auto_track_width": true, "hidden_nets": [], diff --git a/software/dumber3/.settings/com.st.stm32cube.ide.mcu.sfr.prefs b/software/dumber3/.settings/com.st.stm32cube.ide.mcu.sfr.prefs new file mode 100644 index 0000000..7f2d556 --- /dev/null +++ b/software/dumber3/.settings/com.st.stm32cube.ide.mcu.sfr.prefs @@ -0,0 +1,3 @@ +eclipse.preferences.version=1 +svd_custom_file_path= +svd_file_path=/opt/st/stm32cubeide_1.11.0/plugins/com.st.stm32cube.ide.mcu.productdb.debug_2.0.400.202211151459/resources/cmsis/STMicroelectronics_CMSIS_SVD/STM32L0x1.svd diff --git a/software/dumber3/.settings/stm32cubeide.project.prefs b/software/dumber3/.settings/stm32cubeide.project.prefs index f16c2df..54b048a 100644 --- a/software/dumber3/.settings/stm32cubeide.project.prefs +++ b/software/dumber3/.settings/stm32cubeide.project.prefs @@ -1,5 +1,5 @@ 2F62501ED4689FB349E356AB974DBE57=4996C471296F89DC866BF9D3036717E1 66BE74F758C12D739921AEA421D593D3=1 8DF89ED150041C4CBC7CB9A9CAA90856=4996C471296F89DC866BF9D3036717E1 -DC22A860405A8BF2F2C095E5B6529F12=F7414D73CC8C5DF69E5E7FD8F14B7093 +DC22A860405A8BF2F2C095E5B6529F12=3270C02385F02E4A61A1148896BE5016 eclipse.preferences.version=1 diff --git a/software/dumber3/Application/xbee.c b/software/dumber3/Application/xbee.c index efe7e4b..d8e2551 100644 --- a/software/dumber3/Application/xbee.c +++ b/software/dumber3/Application/xbee.c @@ -131,24 +131,28 @@ int XBEE_SendData(char* data) { int status = XBEE_OK; // Prevents successive calls to overlap - state = xSemaphoreTake(xHandleSemaphoreTX, pdMS_TO_TICKS(XBEE_TX_SEMAPHORE_WAIT)); // wait max 500 ms (to avoid interlocking) + //state = xSemaphoreTake(xHandleSemaphoreTX, pdMS_TO_TICKS(XBEE_TX_SEMAPHORE_WAIT)); // wait max 500 ms (to avoid interlocking) - if (state != pdFALSE) { /* test semaphore take answer - if answer is false, it means timeout appends - We should probably reset something in "else" branch */ + //if (state != pdFALSE) { /* test semaphore take answer + // if answer is false, it means timeout appends + // We should probably reset something in "else" branch */ - strncpy((char*)txBuffer,data,XBEE_TX_BUFFER_MAX_LENGTH-1); - txBuffer[XBEE_TX_BUFFER_MAX_LENGTH-1]=0; - txRemainingData = strlen((char*)txBuffer); + while (LL_USART_IsEnabledIT_TXE(hlpuart1.Instance)) { + vTaskDelay(pdMS_TO_TICKS(1)); + } - if (txRemainingData!=0) { - txIndex =1; - txRemainingData=txRemainingData-1; + strncpy((char*)txBuffer,data,XBEE_TX_BUFFER_MAX_LENGTH-1); + txBuffer[XBEE_TX_BUFFER_MAX_LENGTH-1]=0; + txRemainingData = strlen((char*)txBuffer); - LL_USART_TransmitData8(hlpuart1.Instance, txBuffer[0]); - LL_USART_EnableIT_TXE(hlpuart1.Instance); // enable TX Interrupt - } - } else status= XBEE_TX_TIMEOUT; + if (txRemainingData!=0) { + txIndex =1; + txRemainingData=txRemainingData-1; + + LL_USART_TransmitData8(hlpuart1.Instance, txBuffer[0]); + LL_USART_EnableIT_TXE(hlpuart1.Instance); // enable TX Interrupt + } + //} else status= XBEE_TX_TIMEOUT; return status; } @@ -158,7 +162,7 @@ void XBEE_TX_IRQHandler(void) { if (txRemainingData==0) { // No more data, disable TXE bit LL_USART_DisableIT_TXE(hlpuart1.Instance); - xSemaphoreGiveFromISR( xHandleSemaphoreTX, &xHigherPriorityTaskWoken ); + //xSemaphoreGiveFromISR( xHandleSemaphoreTX, &xHigherPriorityTaskWoken ); } else { LL_USART_TransmitData8(hlpuart1.Instance, txBuffer[txIndex]); txIndex++; @@ -182,7 +186,6 @@ void XBEE_TX_IRQHandler(void) { * \param params not used */ void XBEE_RxThread(void* params) { - //XBEE_INCOMING_FRAME *incomingFrame; char* incomingData; rxCmdLength=0; rxIndex=0; @@ -196,8 +199,11 @@ void XBEE_RxThread(void* params) { while (1) { if (xSemaphoreTake(xHandleSemaphoreRX, portMAX_DELAY)==pdTRUE) { // wait forever + if (rxCmdLength> XBEE_RX_BUFFER_MAX_LENGTH) + rxCmdLength = XBEE_RX_BUFFER_MAX_LENGTH; + incomingData = (char*)malloc(rxCmdLength+1); // +1 for ending zero ! - strncpy (incomingData, (char*)rxBuffer, XBEE_RX_BUFFER_MAX_LENGTH); + strncpy (incomingData, (char*)rxBuffer, rxCmdLength+1); rxCmdLength=0; // reset counters for next command rxIndex=0; diff --git a/software/dumber3/Core/Src/stm32l0xx_hal_msp.c b/software/dumber3/Core/Src/stm32l0xx_hal_msp.c index ad10b42..0f64c61 100644 --- a/software/dumber3/Core/Src/stm32l0xx_hal_msp.c +++ b/software/dumber3/Core/Src/stm32l0xx_hal_msp.c @@ -178,7 +178,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* huart) HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); /* LPUART1 interrupt Init */ - HAL_NVIC_SetPriority(LPUART1_IRQn, 2, 0); + HAL_NVIC_SetPriority(LPUART1_IRQn, 3, 0); HAL_NVIC_EnableIRQ(LPUART1_IRQn); /* USER CODE BEGIN LPUART1_MspInit 1 */ //HAL_NVIC_SetPriority(LPUART1_IRQn, 3, 0); diff --git a/software/dumber3/Core/Src/syscalls.c b/software/dumber3/Core/Src/syscalls.c index 5bbf955..73a34f9 100644 --- a/software/dumber3/Core/Src/syscalls.c +++ b/software/dumber3/Core/Src/syscalls.c @@ -37,6 +37,8 @@ extern int __io_putchar(int ch) __attribute__((weak)); extern int __io_getchar(void) __attribute__((weak)); +extern uint8_t ucHeap[ configTOTAL_HEAP_SIZE ]; + char *__env[1] = { 0 }; char **environ = __env; @@ -45,24 +47,26 @@ char **environ = __env; /* Functions */ void* malloc(size_t size) { - void* ptr = NULL; + void* ptr = NULL; - if(size > 0) - { - // We simply wrap the FreeRTOS call into a standard form - ptr = pvPortMalloc(size); - } // else NULL if there was an error + if(size > 0) + { + // We simply wrap the FreeRTOS call into a standard form + ptr = pvPortMalloc(size); + } // else NULL if there was an error - return ptr; + return ptr; } void free(void* ptr) { - if(ptr) - { - // We simply wrap the FreeRTOS call into a standard form - vPortFree(ptr); - } + if (ptr) + { + if ((ptr>=(void*)ucHeap) && (ptr<=(void*)ucHeap+configTOTAL_HEAP_SIZE)) { + // We simply wrap the FreeRTOS call into a standard form + vPortFree(ptr); + } + } } void initialise_monitor_handles() @@ -95,7 +99,7 @@ __attribute__((weak)) int _read(int file, char *ptr, int len) *ptr++ = __io_getchar(); } -return len; + return len; } __attribute__((weak)) int _write(int file, char *ptr, int len) diff --git a/software/dumber3/Middlewares/Third_Party/FreeRTOS/Source/portable/MemMang/heap_4.c b/software/dumber3/Middlewares/Third_Party/FreeRTOS/Source/portable/MemMang/heap_4.c index 23714eb..4d937cd 100644 --- a/software/dumber3/Middlewares/Third_Party/FreeRTOS/Source/portable/MemMang/heap_4.c +++ b/software/dumber3/Middlewares/Third_Party/FreeRTOS/Source/portable/MemMang/heap_4.c @@ -61,7 +61,7 @@ task.h is included from an application file. */ heap - probably so it can be placed in a special segment or address. */ extern uint8_t ucHeap[ configTOTAL_HEAP_SIZE ]; #else - static uint8_t ucHeap[ configTOTAL_HEAP_SIZE ]; + /*static*/ uint8_t ucHeap[ configTOTAL_HEAP_SIZE ]; #endif /* configAPPLICATION_ALLOCATED_HEAP */ /* Define the linked list structure. This is used to link free blocks in order diff --git a/software/dumber3/TestsPlans/tests.c b/software/dumber3/TestsPlans/tests.c index 57dae3f..b7d9a4b 100644 --- a/software/dumber3/TestsPlans/tests.c +++ b/software/dumber3/TestsPlans/tests.c @@ -72,6 +72,7 @@ void TESTS_BasicTests(void* params) { CMD_Generic* cmd; char* ans; + char str[100]; ledsStates = leds_run; MESSAGE_SendMailbox(LEDS_Mailbox, MSG_ID_LED_ETAT, APPLICATION_Mailbox, (void*)&ledsStates); // show program is running @@ -114,7 +115,6 @@ void TESTS_BasicTests(void* params) { while (1) { int length; - char* str; msg = MESSAGE_ReadMailbox(APPLICATION_Mailbox); // Wait for a message from Xbee @@ -132,68 +132,81 @@ void TESTS_BasicTests(void* params) { cmd = cmdDecode((char*)msg.data, strlen((char*)msg.data)); free(msg.data); - str = (char*)malloc(100); - str[0] = 0; // empty string + str[0]=0; switch (cmd->type) { case CMD_PING: snprintf(str, 99, "PING received\r"); cmdSendAnswer(ANS_OK); break; case CMD_RESET: + snprintf(str, 99, "RESET received\r"); cmdSendAnswer(ANS_OK); break; case CMD_START_WITH_WATCHDOG: + snprintf(str, 99, "START with Watchdog received\r"); cmdSendAnswer(ANS_OK); break; case CMD_RESET_WATCHDOG: + snprintf(str, 99, "RESET Watchdog received\r"); cmdSendAnswer(ANS_OK); break; case CMD_GET_BATTERY: + snprintf(str, 99, "GET_BATTERY received\r"); cmdSendBatteryLevel(ANS_BAT_OK); break; case CMD_GET_VERSION: + snprintf(str, 99, "GET_VERSION received\r"); cmdSendVersion(); break; case CMD_START_WITHOUT_WATCHDOG: + snprintf(str, 99, "START without Watchdog received\r"); cmdSendAnswer(ANS_OK); break; case CMD_MOVE: + snprintf(str, 99, "MOVE received\r"); cmdSendAnswer(ANS_OK); break; case CMD_TURN: + snprintf(str, 99, "TURN received\r"); cmdSendAnswer(ANS_OK); break; case CMD_GET_BUSY_STATE: + snprintf(str, 99, "GET_BUSY_STATE received\r"); cmdSendBusyState(ANS_STATE_BUSY); break; case CMD_TEST: + snprintf(str, 99, "TEST received\r"); cmdSendAnswer(ANS_OK); break; case CMD_DEBUG: + snprintf(str, 99, "DEBUG received\r"); cmdSendAnswer(ANS_OK); break; case CMD_POWER_OFF: + snprintf(str, 99, "POWER_OFF received\r"); cmdSendAnswer(ANS_OK); break; default: + snprintf(str, 99, "Unknown command\r"); cmdSendAnswer(ANS_UNKNOWN); break; } + MESSAGE_SendMailbox(XBEE_Mailbox, MSG_ID_XBEE_ANS, APPLICATION_Mailbox, (void*)str); } } @@ -201,10 +214,10 @@ void TESTS_BasicTests(void* params) { case BATTERY_Tests: while (1) { - char* str; + //char* str; msg = MESSAGE_ReadMailbox(APPLICATION_Mailbox); // Wait for a message from Xbee - str = (char*)malloc(100); /* allocate a buffer of 100 bytes */ + //str = (char*)malloc(100); /* allocate a buffer of 100 bytes */ str[0]=0; switch (msg.id) { @@ -224,7 +237,7 @@ void TESTS_BasicTests(void* params) { snprintf(str, 99, "Charge error (plug in)\r"); break; default: - free(str); // buffer alloué non utilisé + //free(str); // buffer alloué non utilisé break; } diff --git a/software/monitor/monitor-python-qt/Images_CMD.txt b/software/monitor/monitor-python-qt/Images_CMD.txt new file mode 100644 index 0000000..b253fad --- /dev/null +++ b/software/monitor/monitor-python-qt/Images_CMD.txt @@ -0,0 +1,14 @@ +COPN +AACK + +CIMG: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 + + + +CIMG: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 + + + + +CIMG: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 +CPOS:-1;0.000000;0.000000;0.000000;0.000000;0.000000